public ReorderingEventArgs(GridViewDataControl sourceGrid, IEnumerable <object> draggedItems, int dropIndex)
     : base(false)
 {
     this.SourceGrid   = sourceGrid;
     this.DraggedItems = draggedItems;
     this.DropIndex    = dropIndex;
 }
Example #2
0
        public static void Export(GridViewDataControl grid, params string[] titles)
        {
            var filePath = Path.GetTempFileName().Replace(".tmp", ".pdf");
            var document = CreateDocument(grid);

            var documentHeader = CreateHeader(titles);
            document.Sections.First.Headers.Default = new Header() { Body = documentHeader };

            if (document != null)
            {
                document.LayoutMode = DocumentLayoutMode.Paged;
                document.Measure(RadDocument.MAX_DOCUMENT_SIZE);
                document.SectionDefaultPageMargin = new Padding(40, 60, 30, 30);

                document.Arrange(new RectangleF(PointF.Empty, document.DesiredSize));

                IDocumentFormatProvider provider = new PdfFormatProvider();

                using (Stream stream = new FileStream(filePath, FileMode.Create))
                {
                    provider.Export(document, stream);
                }
            }

            Process.Start(filePath);
        }
        /// <summary>
        /// Convert GridView to Printer-Friendly version of a GridView
        /// </summary>
        /// <param name="source">Input GridView</param>
        /// <returns>Printer-Friendly version of source</returns>
        static GridViewDataControl ToPrintFriendlyGrid(GridViewDataControl source)
        {
            RadGridView grid = new RadGridView();

            grid.ItemsSource            = source.ItemsSource;
            grid.RowIndicatorVisibility = Visibility.Collapsed;
            grid.ShowGroupPanel         = false;
            grid.CanUserFreezeColumns   = false;
            grid.IsFilteringAllowed     = false;
            grid.AutoExpandGroups       = true;
            grid.AutoGenerateColumns    = false;

            foreach (GridViewDataColumn column in source.Columns.OfType <GridViewDataColumn>())
            {
                GridViewDataColumn newColumn = new GridViewDataColumn();
                newColumn.Width        = column.ActualWidth;
                newColumn.DisplayIndex = column.DisplayIndex;
                //newColumn.DataMemberBinding = new System.Windows.Data.Binding(column.UniqueName);
                newColumn.DataMemberBinding = column.DataMemberBinding; // Better to just copy the references to get all the custom formatting
                newColumn.DataFormatString  = column.DataFormatString;
                newColumn.TextAlignment     = column.TextAlignment;
                newColumn.Header            = column.Header;
                newColumn.Footer            = column.Footer;
                grid.Columns.Add(newColumn);
            }

            StyleManager.SetTheme(grid, StyleManager.GetTheme(grid));

            grid.SortDescriptors.AddRange(source.SortDescriptors);
            grid.GroupDescriptors.AddRange(source.GroupDescriptors);
            grid.FilterDescriptors.AddRange(source.FilterDescriptors);

            return(grid);
        }
        private void gridView_DataLoading(object sender, GridViewDataLoadingEventArgs e)
        {
            GridViewDataControl dataControl = (GridViewDataControl)sender;

            if (dataControl.ParentRow != null)
            {
                dataControl.GridLinesVisibility  = GridLinesVisibility.None;
                dataControl.CanUserFreezeColumns = false;
                dataControl.ShowGroupPanel       = false;
                dataControl.AutoGenerateColumns  = false;

                GridViewDataColumn column = new GridViewDataColumn();
                column.Header            = "Order ID";
                column.DataMemberBinding = new System.Windows.Data.Binding("OrderID");
                dataControl.Columns.Add(column);

                column                   = new GridViewDataColumn();
                column.Header            = "Product ID";
                column.DataMemberBinding = new System.Windows.Data.Binding("ProductID");
                dataControl.Columns.Add(column);

                column                   = new GridViewDataColumn();
                column.Header            = "Unit Price";
                column.DataFormatString  = "{0:c}";
                column.DataMemberBinding = new System.Windows.Data.Binding("UnitPrice");
                dataControl.Columns.Add(column);

                column                   = new GridViewDataColumn();
                column.Header            = "Quantity";
                column.DataMemberBinding = new System.Windows.Data.Binding("Quantity");
                dataControl.Columns.Add(column);
            }
        }
        /// <summary>
        /// Invalidates aggregate results by assigning <see cref="Constants.AggregateCalculatingPlaceHolder"/> value.
        /// </summary>
        /// <param name="grid">The grid control.</param>
        /// <param name="aggregateDefinitions">The aggregate definition collection.</param>
        public static void InvalidateAggregateResults(GridViewDataControl grid, IList<AggregateDefinition> aggregateDefinitions = null)
        {
            if (grid == null)
                return;

            if (aggregateDefinitions == null)
            {
                foreach (var column in grid.Columns)
                {
                    foreach (var aggregateFunction in column.AggregateFunctions)
                    {
                        ((AggregateFunction<object, object>)aggregateFunction)
                            .AggregationExpression = objects => Constants.AggregateCalculatingPlaceHolder;
                    }
                }
            }
            else
            {
                var functionsToRecalculate = aggregateDefinitions.Select(x => x.FunctionName);
                var availableFunctions = grid.Columns.SelectMany<GridViewColumn, AggregateFunction>(x => x.AggregateFunctions).ToList();

                foreach (var functionName in functionsToRecalculate)
                {
                    var aggregateFunction = availableFunctions.FirstOrDefault(x => x.FunctionName == functionName);
                    if (aggregateFunction != null)
                    {
                        ((AggregateFunction<object, object>) aggregateFunction)
                            .AggregationExpression = objects => Constants.AggregateCalculatingPlaceHolder;
                    }
                }
            }

            grid.CalculateAggregates();
        }
Example #6
0
        public static void Export(GridViewDataControl grid, params string[] titles)
        {
            var filePath = Path.GetTempFileName().Replace(".tmp", ".pdf");
            var document = CreateDocument(grid);

            var documentHeader = CreateHeader(titles);

            document.Sections.First.Headers.Default = new Header()
            {
                Body = documentHeader
            };

            if (document != null)
            {
                document.LayoutMode = DocumentLayoutMode.Paged;
                document.Measure(RadDocument.MAX_DOCUMENT_SIZE);
                document.SectionDefaultPageMargin = new Padding(40, 60, 30, 30);

                document.Arrange(new RectangleF(PointF.Empty, document.DesiredSize));

                IDocumentFormatProvider provider = new PdfFormatProvider();

                using (Stream stream = new FileStream(filePath, FileMode.Create))
                {
                    provider.Export(document, stream);
                }
            }

            Process.Start(filePath);
        }
        private void RadGridView1_DataLoading(object sender, GridViewDataLoadingEventArgs e)
        {
            GridViewDataControl dataControl = (GridViewDataControl)sender;

            if (dataControl.ParentRow != null)
            {
                dataControl.GridLinesVisibility  = GridLinesVisibility.None;
                dataControl.ShowGroupPanel       = false;
                dataControl.AutoGenerateColumns  = false;
                dataControl.CanUserFreezeColumns = false;
                dataControl.IsReadOnly           = true;
                dataControl.ChildTableDefinitions.Clear();


                GridViewDataColumn column = new GridViewDataColumn();
                column.DataMemberBinding = new Binding("EmployeeID");
                dataControl.Columns.Add(column);

                column = new GridViewDataColumn();
                column.DataMemberBinding = new Binding("FirstName");
                dataControl.Columns.Add(column);

                column = new GridViewDataColumn();
                column.DataMemberBinding = new Binding("LastName");
                dataControl.Columns.Add(column);

                column = new GridViewDataColumn();
                column.DataMemberBinding = new Binding("Title");
                dataControl.Columns.Add(column);
            }
        }
Example #8
0
        static GridViewDataControl ToPrintFriendlyGrid(GridViewDataControl source)
        {
            var grid = new RadGridView()
            {
                ItemsSource            = source.ItemsSource,
                RowIndicatorVisibility = Visibility.Collapsed,
                ShowGroupPanel         = false,
                CanUserFreezeColumns   = false,
                IsFilteringAllowed     = false,
                AutoExpandGroups       = true,
                AutoGenerateColumns    = false
            };

            foreach (var column in source.Columns.OfType <GridViewDataColumn>())
            {
                var newColumn = new GridViewDataColumn();
                newColumn.DataMemberBinding = new System.Windows.Data.Binding(column.UniqueName);
                grid.Columns.Add(newColumn);
            }

            StyleManager.SetTheme(grid, StyleManager.GetTheme(grid));

            grid.SortDescriptors.AddRange(source.SortDescriptors);
            grid.GroupDescriptors.AddRange(source.GroupDescriptors);
            grid.FilterDescriptors.AddRange(source.FilterDescriptors);

            return(grid);
        }
Example #9
0
        private void gridView_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            GridViewDataControl dataControl = (GridViewDataControl)sender;

            if (dataControl != null)
            {
                this.dataPager.SetBinding(RadDataPager.SourceProperty, new Binding("Items")
                {
                    Source = this.gridView
                });

                // TODO:

                /*
                 * // CreateDataPager(dataControl);
                 * this.BindDataPager(this.gridPager, dataControl);
                 *
                 * ObservableCollection<Pais> items = this.LoadPaises();
                 *
                 * SetGridSource(dataControl, items);
                 */

                //this.ApplySkinFromPath(".\\Skins\\BlueSkin.xaml");
                if (string.IsNullOrEmpty(this.defaultSkinName))
                {
                    this.ApplySkinFromPath(DEFAULT_SKIN);
                }
                else
                {
                    this.ApplySkinFromPath(this.defaultSkinName);
                }
            }
        }
Example #10
0
        // Remove from here!
        private void paisesGridView_NewItem(object sender, Telerik.Windows.Controls.GridView.GridViewAddingNewEventArgs e)
        {
            // No need for this
            //e.NewObject = new Pais();
            GridViewDataControl grid = e.OwnerGridViewItemsControl;

            grid.CurrentColumn = grid.Columns[0];
        }
 public CustomKeyboardCommandProvider(GridViewDataControl grid) : base(grid)
 {
     if (grid == null)
     {
         throw new ArgumentNullException("grid", "Invalid value: Null");
     }
     this.parentGrid = grid;
 }
Example #12
0
        private void dgPortfolioDetails_DataLoading(object sender, GridViewDataLoadingEventArgs e)
        {
            GridViewDataControl dataControl = (GridViewDataControl)sender;

            if (dataControl.ParentRow != null)
            {
                //dataControl is the child gridview
                dataControl.ShowGroupPanel = false;
            }
        }
        private void gridView_DataLoaded(object sender, System.EventArgs e)
        {
            //this.gridStatusInfo = "Carga de datos completa!";

            GridViewDataControl dataControl = (GridViewDataControl)sender;

            if (dataControl != null)
            {
                dataControl.IsBusy = false;
            }
        }
        // 2017-08-02
        // need to break this dependency
        //public UserControlView(IUserControlService serviceContext) : this()
        //{
        //    this.genericTemplate = serviceContext;
        //}

        #region Grid Events
        private void gridView_DataLoading(object sender, Telerik.Windows.Controls.GridView.GridViewDataLoadingEventArgs e)
        {
            //this.gridStatusInfo = "Cargando datos ...";

            GridViewDataControl dataControl = (GridViewDataControl)sender;

            if (dataControl != null)
            {
                dataControl.IsBusy = true;
            }
        }
Example #15
0
        public static void Print(this GridViewDataControl source, bool showDialog)
        {
            var dialog       = new PrintDialog();
            var dialogResult = showDialog ? dialog.ShowDialog() : true;

            if (dialogResult == true)
            {
                var viewer = new DocumentViewer();
                viewer.Document = ToFixedDocument(ToPrintFriendlyGrid(source), dialog);
                dialog.PrintDocument(viewer.Document.DocumentPaginator, "");
            }
        }
        /// <summary>
        /// Updates aggregate results.
        /// </summary>
        /// <param name="grid">The grid control.</param>
        /// <param name="aggregateResults">The aggregate result collection.</param>
        /// <param name="aggregateDefinitions">The aggregate definition collection.</param>
        public static void UpdateAggregates(
            GridViewDataControl grid,
            AggregateResultCollection aggregateResults,
            IList<AggregateDefinition> aggregateDefinitions)
        {
            if (grid == null)
                return;

            ProcessAggregateResults(
                grid, aggregateResults, aggregateDefinitions);

            grid.CalculateAggregates();
        }
Example #17
0
        public static void PrintPreview(this GridViewDataControl source)
        {
            var window = new Window()
            {
                Title   = "Print Preview",
                Content = new DocumentViewer()
                {
                    Document = ToFixedDocument(ToPrintFriendlyGrid(source), new PrintDialog())
                }
            };

            window.ShowDialog();
        }
        /// <summary>
        /// Perform a Print on GridView source
        /// </summary>
        /// <param name="source">Input GridView</param>
        /// <param name="showDialog">True to show print dialog before printing</param>
        /// <param name="orientation">Page Orientation (i.e. Portrait vs. Landscape)</param>
        /// <param name="zoom">Zoom Enumeration to specify how pages are stretched in print and preview</param>
        public static void Print(GridViewDataControl source, bool showDialog = true, System.Printing.PageOrientation orientation = System.Printing.PageOrientation.Landscape, ZoomType zoom = ZoomType.TwoWide)
        {
            PrintDialog dialog       = new PrintDialog();
            bool?       dialogResult = showDialog ? dialog.ShowDialog() : true;

            if (dialogResult == true)
            {
                DocumentViewer viewer = new DocumentViewer();
                viewer.Document = ToFixedDocument(ToPrintFriendlyGrid(source), dialog, orientation);
                Zoom(viewer, zoom);
                dialog.PrintDocument(viewer.Document.DocumentPaginator, "");
            }
        }
        private void Export(GridViewDataControl grid, string extension, BinaryWorkbookFormatProviderBase provider)
        {
            SaveFileDialog dialog = new SaveFileDialog();

            dialog.DefaultExt = "." + extension;

            if (dialog.ShowDialog() == true)
            {
                using (var output = dialog.OpenFile())
                {
                    provider.Export(this.ExportWorkbook(this.clubsGrid), output);
                }
            }
        }
Example #20
0
 /// <summary>
 /// Returns RadRowItem by recursively searching in GridViewDataControl
 /// </summary>
 /// <param name="dataControl">GridViewDataControl</param>
 /// <param name="item">Data Item</param>
 /// <returns>RadRowItem</returns>
 internal static RadRowItem GetContainerFromDataItem(this GridViewDataControl dataControl, object item)
 {
     if (item == null || dataControl == null)
     {
         return(null);
     }
     if (dataControl.IsGrouping)
     {
         return(dataControl.GetContainerFromItemRecursive(item));
     }
     else
     {
         return(dataControl.ItemContainerGenerator.ContainerFromItem(item) as RadRowItem);
     }
 }
Example #21
0
        private void ShowDropPositionFeedbackPresenter(GridViewDataControl gridView, GridViewRow row, DropPosition lastRowDropPosition)
        {
            if (!this.IsDropPositionFeedbackAvailable())
            {
                return;
            }
            var yOffset = this.GetDropPositionFeedbackOffset(row, lastRowDropPosition);

            this.dropPositionFeedbackPresenter.Visibility      = Visibility.Visible;
            this.dropPositionFeedbackPresenter.Width           = row.ActualWidth;
            this.dropPositionFeedbackPresenter.RenderTransform = new TranslateTransform()
            {
                Y = yOffset
            };
        }
Example #22
0
        //加载过滤设定;
        public static void LoadColumnFilters(GridViewDataControl grid
                                             , IEnumerable <FilterSetting> savedSettings)
        {
            if (savedSettings.Count() == 0)
            {
                grid.FilterDescriptors.Clear();
                return;
            }

            grid.FilterDescriptors.SuspendNotifications();

            foreach (FilterSetting setting in savedSettings)
            {
                Telerik.Windows.Controls.GridViewColumn column = grid.Columns[setting.ColumnUniqueName];

                IColumnFilterDescriptor columnFilter = column.ColumnFilterDescriptor;

                foreach (object distinctValue in setting.SelectedDistinctValues)
                {
                    columnFilter.DistinctFilter.AddDistinctValue(distinctValue);
                }

                if (setting.Filter1 != null)
                {
                    columnFilter.FieldFilter.Filter1.Operator        = setting.Filter1.Operator;
                    columnFilter.FieldFilter.Filter1.Value           = setting.Filter1.Value;
                    columnFilter.FieldFilter.Filter1.IsCaseSensitive = setting.Filter1.IsCaseSensitive;
                }

                columnFilter.FieldFilter.LogicalOperator = setting.FieldFilterLogicalOperator;

                if (setting.Filter2 != null)
                {
                    columnFilter.FieldFilter.Filter2.Operator        = setting.Filter2.Operator;
                    columnFilter.FieldFilter.Filter2.Value           = setting.Filter2.Value;
                    columnFilter.FieldFilter.Filter2.IsCaseSensitive = setting.Filter2.IsCaseSensitive;
                }
            }

            grid.FilterDescriptors.ResumeNotifications();
        }
        private Workbook ExportWorkbook(GridViewDataControl grid)
        {
            var imageExtension = "png";
            var imageWidth     = 20;
            var imageHeight    = 23;
            var padding        = 5;

            Workbook  workbook    = grid.ExportToWorkbook();
            Worksheet worksheet   = workbook.ActiveWorksheet;
            var       usedRows    = worksheet.UsedCellRange.RowCount;
            var       usedColumns = worksheet.UsedCellRange.ColumnCount;

            for (int i = 0; i < usedRows; i++)
            {
                for (int j = 0; j < usedColumns; j++)
                {
                    var cell      = worksheet.Cells[i, j];
                    var cellValue = cell.GetValue().Value.RawValue;
                    if (cellValue.Contains(string.Format(".{0}", imageExtension)))
                    {
                        FloatingImage image = new FloatingImage(worksheet, new CellIndex(i, j), padding, padding);

                        Stream stream = File.Open("../../" + cellValue, FileMode.Open, FileAccess.Read);

                        using (stream)
                        {
                            image.ImageSource = new Telerik.Windows.Documents.Media.ImageSource(stream, imageExtension);
                        }

                        image.Width  = imageWidth;
                        image.Height = imageHeight;

                        worksheet.Shapes.Add(image);
                        cell.SetValue(string.Empty);
                        worksheet.Rows[i].SetHeight(new RowHeight(imageHeight + padding * 2, true));
                    }
                }
            }

            return(workbook);
        }
        private void gridView_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            //if (this.genericTemplate == null)
            //{
            //    return;
            //}
            GridViewDataControl dataControl = (GridViewDataControl)sender;

            if (dataControl != null)
            {
                //dataControl.ItemsSource = genericLocalidades.
                // how often does it come here?
                //dataControl.Columns.Clear();
                dataControl.Columns.Add(new MyButtonColumn(new RoutedEventHandler(this.ButtonTest_Click))
                {
                    Header = "Editar"
                });

                // TODO: 2017-07-31 + 2017-08-02
                dataControl.Columns.AddRange(this.myViewModel.GridColumns);    // this.gridCols

                // Stack Overflow!
                dataControl.ItemsSource = this.myViewModel.GridContent;  // this.gridContent;

                this.dataPager.SetBinding(RadDataPager.SourceProperty, new Binding("Items")
                {
                    Source = this.gridView
                });

                // TODO:

                /*
                 * // CreateDataPager(dataControl);
                 * this.BindDataPager(this.gridPager, dataControl);
                 *
                 * ObservableCollection<Pais> items = this.LoadPaises();
                 *
                 * SetGridSource(dataControl, items);
                 */
            }
        }
Example #25
0
        //得到过滤设定;
        public static IEnumerable <FilterSetting> SaveColumnFilters(GridViewDataControl grid)
        {
            IList <FilterSetting> settings = new List <FilterSetting>();

            foreach (IFilterDescriptor filter in grid.FilterDescriptors)
            {
                if (filter is IColumnFilterDescriptor columnFilter)
                {
                    FilterSetting setting = new FilterSetting {
                        ColumnUniqueName = columnFilter.Column.UniqueName
                    };

                    setting.SelectedDistinctValues.AddRange(columnFilter.DistinctFilter.DistinctValues);

                    if (columnFilter.FieldFilter.Filter1.IsActive)
                    {
                        setting.Filter1 = new FilterDescriptorProxy {
                            Operator        = columnFilter.FieldFilter.Filter1.Operator,
                            Value           = columnFilter.FieldFilter.Filter1.Value,
                            IsCaseSensitive = columnFilter.FieldFilter.Filter1.IsCaseSensitive
                        };
                    }

                    setting.FieldFilterLogicalOperator = columnFilter.FieldFilter.LogicalOperator;

                    if (columnFilter.FieldFilter.Filter2.IsActive)
                    {
                        setting.Filter2 = new FilterDescriptorProxy {
                            Operator        = columnFilter.FieldFilter.Filter2.Operator,
                            Value           = columnFilter.FieldFilter.Filter2.Value,
                            IsCaseSensitive = columnFilter.FieldFilter.Filter2.IsCaseSensitive
                        };
                    }

                    settings.Add(setting);
                }
            }

            return(settings);
        }
Example #26
0
        private static RadDocument CreateDocument(GridViewDataControl grid)
        {
            RadDocument document;

            using (var stream = new MemoryStream())
            {
                EventHandler <GridViewElementExportingEventArgs> elementExporting = (s, e) =>
                {
                    if (e.Element == ExportElement.Table)
                    {
                        e.Attributes["border"] = "0";
                    }
                };

                grid.ElementExporting += elementExporting;

                grid.Export(stream, new GridViewExportOptions
                {
                    Format            = ExportFormat.Html,
                    ShowColumnFooters = grid.ShowColumnFooters,
                    ShowColumnHeaders = grid.ShowColumnHeaders,
                    ShowGroupFooters  = grid.ShowGroupFooters
                });

                grid.ElementExporting -= elementExporting;

                stream.Position = 0;

                document = new HtmlFormatProvider().Import(stream);

                foreach (Span span in document.EnumerateChildrenOfType <Span>())
                {
                    span.FontSize   = 12;
                    span.FontFamily = new FontFamily("Arial");
                }
            }

            return(document);
        }
        /// <summary>
        /// Perform a Print Preview on GridView source
        /// </summary>
        /// <param name="source">Input GridView</param>
        /// <param name="orientation">Page Orientation (i.e. Portrait vs. Landscape)</param>
        /// <param name="zoom">Zoom Enumeration to specify how pages are stretched in print and preview</param>
        public static void PrintPreview(GridViewDataControl source, System.Printing.PageOrientation orientation = System.Printing.PageOrientation.Landscape, ZoomType zoom = ZoomType.TwoWide)
        {
            Window window = new Window();

            window.Title = "Print Preview";
            if (!string.IsNullOrWhiteSpace(source.ToolTip as string))
            {
                window.Title += " of " + source.ToolTip;
            }
            window.Width  = SystemParameters.PrimaryScreenWidth * 0.92;
            window.Height = SystemParameters.WorkArea.Height;
            window.Left   = constrain(SystemParameters.VirtualScreenWidth - SystemParameters.PrimaryScreenWidth, 0, SystemParameters.VirtualScreenWidth - 11);
            window.Top    = constrain(0, 0, SystemParameters.VirtualScreenHeight - 25);

            DocumentViewer viewer = new DocumentViewer();

            viewer.Document = ToFixedDocument(ToPrintFriendlyGrid(source), new PrintDialog(), orientation);
            Zoom(viewer, zoom);
            window.Content = viewer;

            window.ShowDialog();
        }
Example #28
0
 public ReorderedEventArgs(GridViewDataControl sourceGrid, IEnumerable <object> draggedItems)
     : base()
 {
     this.SourceGrid   = sourceGrid;
     this.DraggedItems = draggedItems;
 }
        /// <summary>
        /// Takes an aggregate result and forms or updates the corresponding aggregate function.
        /// </summary>
        /// <param name="grid">The grid.</param>
        /// <param name="resultCollection">The collection of aggregate results.</param>
        /// <param name="aggregateDefinitions">The collection of aggregate definitions.</param>
        private static void ProcessAggregateResults(GridViewDataControl grid, AggregateResultCollection resultCollection, IList<AggregateDefinition> aggregateDefinitions)
        {
            if (grid == null ||
                resultCollection == null ||
                aggregateDefinitions == null)
            {
                return;
            }

            foreach (var result in resultCollection)
            {
                var aggregateDefinition = aggregateDefinitions.FirstOrDefault(
                        x => x.ColumnName == result.ColumnName && x.SummaryType == result.SummaryType);
                if (aggregateDefinition == null)
                    continue;

                var context = grid.DataContext as IHasColumns;
                if (context == null)
                    return;

                var columnItem = context.Columns.Where(x => x.Property != null).FirstOrDefault(
                        x => string.IsNullOrEmpty(x.AdditionalDataPropertyName)
                                ? x.Property.Name == result.ColumnName
                                : x.AdditionalDataPropertyName == result.ColumnName);

                if (columnItem == null)
                    return;

                var gridColumn = grid.Columns[columnItem.FullName];

                UpdateAggregationResult(gridColumn, columnItem, aggregateDefinition, result);
            }
        }
 public CustomGridViewKeyboardCommand(GridViewDataControl grid) : base(grid)
 {
     this.parentGrid = grid;
 }
Example #31
0
        private static RadDocument CreateDocument(GridViewDataControl grid)
        {
            RadDocument document;

            using (var stream = new MemoryStream())
            {
                EventHandler<GridViewElementExportingEventArgs> elementExporting = (s, e) =>
                {
                    if (e.Element == ExportElement.Table)
                    {
                        e.Attributes["border"] = "0";
                    }
                };

                grid.ElementExporting += elementExporting;

                grid.Export(stream, new GridViewExportOptions
                {
                    Format = ExportFormat.Html,
                    ShowColumnFooters = grid.ShowColumnFooters,
                    ShowColumnHeaders = grid.ShowColumnHeaders,
                    ShowGroupFooters = grid.ShowGroupFooters
                });

                grid.ElementExporting -= elementExporting;

                stream.Position = 0;

                document = new HtmlFormatProvider().Import(stream);

                foreach (Span span in document.EnumerateChildrenOfType<Span>())
                {
                    span.FontSize = 12;
                    span.FontFamily = new FontFamily("Arial");
                }
            }

            return document;
        }
Example #32
0
 private static RadRichTextBox CreateRadRichTextBox(GridViewDataControl grid, PrintSettings settings)
 {
     return new RadRichTextBox
         {
             IsReadOnly = true,
             LayoutMode = DocumentLayoutMode.Paged,
             IsSelectionEnabled = false,
             IsSpellCheckingEnabled = false,
             Document = CreateDocument(grid, settings)
         };
 }
Example #33
0
        private bool Export(GridViewDataControl gridView, string accessDeniedProperties)
        {
            if (_saveFileDialog == null)
            {
                return false;
            }

            if (gridView == null)
            {
                return false;
            }

            if (!string.IsNullOrEmpty(accessDeniedProperties))
            {
                _accessDeniedProperties = accessDeniedProperties.Split('|').ToList();
            }

            using (var stream = _saveFileDialog.OpenFile())
            {
                if (TheExportOptionsViewModel.Value.ExportFileType == ExportFileType.Pdf)
                {
                    var document = CreateDocument(gridView);
                    if (document == null)
                    {
                        return false;
                    }

                    document.LayoutMode = DocumentLayoutMode.Paged;
                    document.Measure(RadDocument.MAX_DOCUMENT_SIZE);
                    document.Arrange(new RectangleF(PointF.Empty, document.DesiredSize));

                    new PdfFormatProvider().Export(document, stream);
                }
                else
                {
                    gridView.ElementExporting += ElementExporting;

                    gridView.Export(stream, new GridViewExportOptions
                    {
                        Format = GetFormat(TheExportOptionsViewModel.Value.ExportFileType),
                        Encoding = new UTF8Encoding(true),
                        ShowColumnFooters = gridView.IsGrouping ? gridView.AggregateResults.Count > 1 : gridView.AggregateResults.Count > 0,
                        ShowGroupFooters = gridView.IsGrouping && gridView.AggregateResults.Count > 1,
                        ShowColumnHeaders = true
                    });

                    gridView.ElementExporting -= ElementExporting;
                }
            }

            return true;
        }
        /// <summary>
        /// Removes aggregate functions.
        /// </summary>
        /// <param name="grid">The grid control.</param>
        /// <param name="aggregateDefinitions">The aggregate definition collection.</param>
        public static void RemoveAggregateFunctions(GridViewDataControl grid, IList<AggregateDefinition> aggregateDefinitions)
        {
            if (grid == null ||
                aggregateDefinitions == null ||
                aggregateDefinitions.Count == 0)
            {
                return;
            }

            var dcColumns = new List<IColumnItem>();

            var dc = grid.DataContext as IHasColumns;
            if (dc != null)
                dcColumns = dc.Columns.ToList();

            foreach (var aggregateDefinition in aggregateDefinitions)
            {
                foreach (var gridColumn in grid.Columns)
                {
                    var func =
                        gridColumn.AggregateFunctions.FirstOrDefault(
                            x => x.FunctionName == aggregateDefinition.FunctionName);

                    if (func != null)
                        gridColumn.AggregateFunctions.Remove(func);


                    if (dcColumns == null)
                        continue;

                    var columnItem = dcColumns.FirstOrDefault(x => x.FullName == gridColumn.UniqueName);
                    if (columnItem == null)
                        continue;

                    var criteria =
                        columnItem.AggregateCriteriaList.FirstOrDefault(
                            x => x.FunctionName == aggregateDefinition.FunctionName);

                    if (criteria != null)
                        columnItem.AggregateCriteriaList.Remove(criteria);
                }
            }
        }
Example #35
0
        private static DataTemplate GetCellTemplate(IColumnItem column, ConverterInfo converterInfo, GridViewDataControl grid)
        {
            string accessDenied = null;

            if ((string)grid.Tag == "SearchGrid")
                accessDenied = string.Format(
                    CultureInfo.InvariantCulture,
                    @"AccessDeniedPropertyList=""{{{{Binding Path={0}, Converter={{{{StaticResource StringToHashSetConverter}}}}}}}}""",
                    Constants.AccessDeniedPropertiesName);

            if ((string)grid.Tag == "SingleCrGrid")
                accessDenied = string.Format(
                    CultureInfo.InvariantCulture,
                    @"SingleCrAccessDeniedList=""{{{{Binding Path={0}, Converter={{{{StaticResource StringToHashSetConverter}}}}}}}}""",
                    Constants.AccessDeniedPropertiesName);

            if ((string)grid.Tag == "MultipleCrGrid")
                accessDenied = string.Format(
                    CultureInfo.InvariantCulture,
                    @"MultiCrAccessDeniedList=""{{{{Binding Path={0}, Converter={{{{StaticResource StringToHashSetConverter}}}}}}}}""",
                    Constants.AccessDeniedPropertiesName);

            var hightlightBehavior = string.Format(CultureInfo.InvariantCulture, 
@"
    <i:Interaction.Behaviors>
        <Behaviors:HightlightBehavior HighlightBrush=""Red""
                                      HighlightFontWeight=""Bold""
                                      HightlightText=""{{{{Binding RelativeSource={{{{RelativeSource AncestorType=UserControl}}}}, Path=DataContext.FilterString}}}}""
                                      {0}
                                      ColumnName=""{1}""
                                      Text=""{{0}}"" />
        <Behaviors:{2} Text=""{{0}}"" />
        </i:Interaction.Behaviors>", accessDenied, column.ColumnName, typeof(HighlightRichTextBehavior).Name);

            var prop = column.Property;
            var stringFormat = string.Empty;

            var numericAttribute =
                (NumericAttribute)
                (from d in prop.GetCustomAttributes(typeof(NumericAttribute), false) select d).FirstOrDefault();

            if (numericAttribute != null)
            {
                switch (numericAttribute.NumericType)
                {
                    case NumericTypes.Numeric:
                        stringFormat = string.Format(CultureInfo.InvariantCulture, "StringFormat=N{0}", numericAttribute.NumberOfDigits);
                        break;

                    case NumericTypes.Currency:
                        stringFormat = string.Format(CultureInfo.InvariantCulture, "StringFormat=C{0}", numericAttribute.NumberOfDigits);
                        break;

                    case NumericTypes.Percentage:
                        stringFormat = string.Format(CultureInfo.InvariantCulture, "StringFormat=P{0}", numericAttribute.NumberOfDigits);
                        break;
                }
            }

            var converter = converterInfo.ConverterString;

            var binding =
                string.Format(CultureInfo.InvariantCulture, "{{Binding {1}{0}{2}{3}}}",
                              prop.Name,
                              string.IsNullOrWhiteSpace(column.Prefix) ? string.Empty : string.Format(CultureInfo.InvariantCulture, "{0}.", column.Prefix),
                              string.IsNullOrWhiteSpace(converter) ? string.Empty : string.Format(CultureInfo.InvariantCulture, ", {0}", converter),
                              string.IsNullOrWhiteSpace(stringFormat) ? string.Empty : string.Format(CultureInfo.InvariantCulture, ", {0}", stringFormat));

            var behavior = string.Format(CultureInfo.InvariantCulture, hightlightBehavior, binding);
            var templateText = string.Format(CultureInfo.InvariantCulture, @"
<DataTemplate
    xmlns=""http://schemas.microsoft.com/client/2007""
    xmlns:i=""http://schemas.microsoft.com/expression/2010/interactivity""
    xmlns:Behaviors=""clr-namespace:Cebos.Common.Behaviors;assembly=Cebos.Veyron.Common.SL"">
     <TextBlock>
        {0}
     </TextBlock>
</DataTemplate>", behavior);
            var itemTemplate = XamlReader.Load(templateText);
            return (DataTemplate)itemTemplate;
        }
Example #36
0
        public static void RemoveColumnFromGrid(GridViewDataControl grid, IColumnItem column)
        {
            if (grid == null)
                return;

            var item = grid.Columns.Cast<GridViewDataColumn>().FirstOrDefault(x => x.UniqueName == column.ColumnName);

            if (item != null)
                grid.Columns.Remove(item);
        }
Example #37
0
        public static void CalculateAggregats(bool isClient, GridViewDataControl grid, AggregateCriteria criteria, IColumnItem currentColumn, string result)
        {
            var f = new AggregateFunction<object, object>
                        {
                            Caption = string.Format(CultureInfo.InvariantCulture, "{0}:", AggregateHelper.GetAttribute(criteria.SummaryType).FullName),
                            FunctionName = string.Format(CultureInfo.InvariantCulture, "{0}{1}", criteria.SelectedColumn, criteria.SummaryType)
                        };

            if (isClient)
                f.AggregationExpression = x => x.ClientCalculateAggregates(criteria);
            else
                f.AggregationExpression = x => result;

            if (currentColumn != null)
            {
                if (grid != null)
                {
                    grid.Columns[currentColumn.FullyQualifiedName].AggregateFunctions.Add(f);
                    var ordered = grid.Columns[currentColumn.FullyQualifiedName].AggregateFunctions.OrderBy(x => AggregateHelper.GetAttribute(AggregateHelper.GetTypeByFullName(x.Caption.Replace(":", null))).Order).ToList();
                    grid.Columns[currentColumn.FullyQualifiedName].AggregateFunctions.Clear();
                    grid.Columns[currentColumn.FullyQualifiedName].AggregateFunctions.AddRange(ordered);
                }

                currentColumn.AggregateCriteriaList.Add(criteria);
            }

            if (!isClient)
                if (grid != null)
                    grid.CalculateAggregates();
        }
 public CustomCommandProvider(GridViewDataControl grid)
     : base(grid)
 {
     this.parentGrid = grid;
 }
Example #39
0
        public void ExportStart(string processSystemName, GridViewDataControl gridView, string accessDeniedProperties)
        {
            TheWindowManager.Value.ShowStatus(new Status { IsBusy = true, Text = LanguageService.Translate("Msg_Exporting") });

            var processType = TheDynamicTypeManager.Value.GetCustomType(processSystemName, "AuditLogCommand", false);

            var auditInfo = new AuditLogInfo
            {
                LogType = 'U',
                ItemId = -1,
                FieldName = string.Format(CultureInfo.InvariantCulture, "Exported by: {0}", Utils.CurrentUserAccountId == -1 ? "admin" : Utils.CurrentUserFullName),
                OldValue = string.Format(CultureInfo.InvariantCulture, "Exported process: {0}", processSystemName),
                NewValue = string.Format(CultureInfo.InvariantCulture, "Exported format: {0}", GetExtension(TheExportOptionsViewModel.Value.ExportFileType))
            };

            MethodCaller.CallFactoryMethod(processType, "BeginInsertEmailLog", new object[] { auditInfo, null });

            var isDataExported = Export(gridView, accessDeniedProperties);

            TheWindowManager.Value.HideBusy();

            if (isDataExported)
            {
                ThePopupFactory.Value.NotifySuccess(LanguageService.Translate("Msg_ProcessExported"));
            }
            else
            {
                ThePopupFactory.Value.NotifyFailure(LanguageService.Translate("Msg_ExportError"));
            }
        }
Example #40
0
        public static void AddColumnToGrid(GridViewDataControl grid, IColumnItem column)
        {
            if (column == null)
                return;

            string fullName = column.IsBase ? string.Format(CultureInfo.InvariantCulture, "{0}.{1}", column.Prefix, column.ColumnName) : column.ColumnName;
            if (column.Property == null)
            {
                var col = new GridViewDataColumn
                              {
                                  Header = column.Header,
                                  UniqueName = fullName,
                                  DataType = column.DataType,
                                  IsGroupable = column.IsGroupable,
                                  Width = column.Width == 0.0 ? new GridViewLength(1, GridViewLengthUnitType.Auto) : column.Width
                              };

                if (grid != null)
                    grid.Columns.Add(col);

                return;
            }

            var converterInfo = GetConverterInfo(column);
            var dict = Application.Current.Resources.MergedDictionaries.First(x => x.Source == new Uri("/Cebos.Veyron.Common.SL;component/Assets/RadGridViewStyles.xaml", UriKind.RelativeOrAbsolute));
            if (IsImage(column.Property))
            {
                var imageWidth = 96;
                var imageHeight = 96;
                var pictureOptionsAttr = (PictureOptionsAttribute)(from d in column.Property.GetCustomAttributes(typeof(PictureOptionsAttribute), false) select d).FirstOrDefault();
                if (pictureOptionsAttr != null)
                {
                    imageWidth = pictureOptionsAttr.SearchWidth;
                    imageHeight = pictureOptionsAttr.SearchHeight;
                }

                var templateText = string.Format(
                    CultureInfo.InvariantCulture, @"
<DataTemplate
    xmlns=""http://schemas.microsoft.com/client/2007""
    xmlns:i=""http://schemas.microsoft.com/expression/2010/interactivity""
    xmlns:Behaviors=""clr-namespace:Cebos.Common.Behaviors;assembly=Cebos.Veyron.Common.SL"">
    <Image Height=""{0}""
           Width=""{1}""
           Stretch=""Uniform""
           Source=""{{Binding {2}{3}, Converter={{StaticResource imageConverter}}}}"">
        <i:Interaction.Behaviors>
            <Behaviors:{4}
                AccessDeniedPropertyList=""{{Binding Path=AccessDeniedProperties, Converter={{StaticResource {5}}}}}""
                ColumnName=""{3}"" />
        </i:Interaction.Behaviors>
    </Image>
</DataTemplate>", imageHeight, imageWidth, string.IsNullOrWhiteSpace(column.Prefix) ? null : string.Format(CultureInfo.InvariantCulture, "{0}.", column.Prefix), column.ColumnName, typeof(HightlightImageBehavior).Name, typeof(
                        StringToHashSetConverter).Name);

                var col = new GridViewDataColumn
                              {
                                  Header = column.Header,
                                  UniqueName = fullName,
                                  DataMemberBinding = new Binding(fullName),
                                  CellTemplate = (DataTemplate)XamlReader.Load(templateText),
                                  FooterCellStyle = (Style)dict["footerCellStyle"],
                                  GroupFooterCellStyle = (Style)dict["groupFooterCellStyle"],
                                  IsGroupable = column.IsGroupable,
                                  DataType = typeof(string),
                                  Width = column.Width == 0.0 ? new GridViewLength(1, GridViewLengthUnitType.Auto) : column.Width
                              };

                if (grid != null)
                    grid.Columns.Add(col);

                return;
            }

            // if item have AdditionalDataPropertyName property equals column name + "Url",
            // then this column will be hyperlink, else normal column.
            if (column.AdditionalDataPropertyName != null)
            {
                var col = new GridViewDataColumn
                              {
                                  Header = column.Header,
                                  UniqueName = fullName,
                                  DataMemberBinding =
                                      new Binding(column.AdditionalDataPropertyName)
                                          {
                                              Converter = converterInfo.ConverterObject,
                                              ConverterParameter = converterInfo.ConverterParameter
                                          },
                                  CellTemplate = GetCellTemplateHyperlink(column),
                                  GroupFooterCellStyle = (Style)dict["groupFooterCellStyle"],
                                  FooterCellStyle = (Style)dict["footerCellStyle"],
                                  IsGroupable = column.IsGroupable,
                                  DataType = column.Property.PropertyType,
                                  Width = column.Width == 0.0 ? new GridViewLength(1, GridViewLengthUnitType.Auto) : column.Width
                              };

                if (grid != null)
                    grid.Columns.Add(col);
            }
            else
            {
                if (column.IsBase && column.ColumnName == Constants.IdColumnName && column.Property.PropertyType == typeof(int))
                {
                    return;
                }

                if (column.IsBase && column.ColumnName == Constants.VersionDate)
                {
                    return;
                }

                if (column.IsBase && column.ColumnName == Constants.VersionNumber)
                {
                    return;
                }

                if (column.IsBase && Constants.DerivedProcessDisplayNameColumnName.Equals(column.ColumnName))
                {
                    return;
                }

                if (grid != null)
                {
                    grid.Columns.Add(new GridViewDataColumn
                                         {
                                             Header = column.Header,
                                             UniqueName = fullName,
                                             DataMemberBinding = new Binding(fullName)
                                                                     {
                                                                         Converter = converterInfo.ConverterObject,
                                                                         ConverterParameter = converterInfo.ConverterParameter
                                                                     },
                                             CellTemplate = GetCellTemplate(column, converterInfo, grid),
                                             GroupFooterCellStyle = (Style)dict["groupFooterCellStyle"],
                                             FooterCellStyle = (Style)dict["footerCellStyle"],
                                             DataType = column.Property.PropertyType,
                                             IsGroupable = true,
                                             Width = column.Width == 0.0 ? new GridViewLength(1, GridViewLengthUnitType.Auto) : column.Width
                                         });
                }
            }
        }
Example #41
0
 public GridColumnFactory(GridViewDataControl grid, ResourceDictionary dictionary)
 {
     _grid = grid;
     _dictionary = dictionary;
 }
Example #42
0
        public void Export()
        {
            // arrange
            var exportUtility = new ExportUtility();
            var privateAccessor = new PrivateAccessor(exportUtility);

            // act
            var result = (bool)privateAccessor.CallMethod("Export", new object[] { null, null });

            // assert
            Assert.IsFalse(result);

            // arrange
            var dialog = Mock.Create<SaveFileDialog>();
            privateAccessor.SetField("_saveFileDialog", dialog);

            // act
            result = (bool)privateAccessor.CallMethod("Export", new object[] { null, null });

            // assert
            Assert.IsFalse(result);

            // arrange
            var exportViewModel = new ExportOptionsViewModel();
            exportUtility.TheExportOptionsViewModel = new Lazy<ExportOptionsViewModel>(() => exportViewModel);

            var grid = new GridViewDataControl();

            using (var stream = new MemoryStream())
            {
                Mock.Arrange(() => dialog.OpenFile()).Returns(stream);

                // act
                result = (bool)privateAccessor.CallMethod("Export", new object[] { grid, "Id|CurrentState" });

                // assert
                Assert.IsTrue(result);
            }

            // arrange
            Mock.Arrange(() => grid.IsGrouping).Returns(true);
            Mock.Arrange(() => grid.Export(Arg.IsAny<Stream>(), Arg.IsAny<GridViewExportOptions>())).DoNothing();
            using (var stream = new MemoryStream())
            {
                Mock.Arrange(() => dialog.OpenFile()).Returns(stream);

                // act
                result = (bool)privateAccessor.CallMethod("Export", new object[] { grid, "Id|CurrentState" });

                // assert
                Assert.IsTrue(result);
            }

            // arrange
            using (var stream = new MemoryStream())
            {
                Mock.Arrange(() => dialog.OpenFile()).Returns(stream);
                exportViewModel.ExportFileType = ExportFileType.Pdf;

                // act
                result = (bool)privateAccessor.CallMethod("Export", new object[] { grid, null });

                // assert
                Assert.IsTrue(result);

                // arrange
                Mock.NonPublic.Arrange(exportUtility, "CreateDocument", grid).DoNothing();

                // act
                result = (bool)privateAccessor.CallMethod("Export", new object[] { grid, null });

                // assert
                Assert.IsFalse(result);
            }

            // arrange
            Mock.Arrange(() => grid.IsGrouping).Returns(false);
            using (var stream = new MemoryStream())
            {
                // arrange
                Mock.Arrange(() => dialog.OpenFile()).Returns(stream);
                Mock.NonPublic.Arrange(exportUtility, "CreateDocument", grid).CallOriginal();

                // act
                result = (bool)privateAccessor.CallMethod("Export", new object[] { grid, null });

                // assert
                Assert.IsTrue(result);
            }
        }
Example #43
0
 public KeyboardCommandProvider(GridViewDataControl grid)
     : base(grid)
 {
     this.parentGrid = grid;
 }
Example #44
0
 public static void ExportFromGrid(GridViewDataControl grid)
 {
     _grid = grid;
     Export();
 }
 public CustomGridKeyboardCommandProvider(GridViewDataControl dataControl)
     : base(dataControl)
 {
     this.dataControl       = dataControl;
     this.ModifiersProvider = () => Keyboard.Modifiers;
 }
Example #46
0
        private RadDocument CreateDocument(GridViewDataControl gridView)
        {
            RadDocument document;

            using (var memoryStream = new MemoryStream())
            {
                gridView.ElementExporting += ElementExporting;

                gridView.Export(memoryStream, new GridViewExportOptions
                        {
                            Format = GetFormat(TheExportOptionsViewModel.Value.ExportFileType),
                            Encoding = new UTF8Encoding(true),
                            ShowColumnFooters = gridView.IsGrouping ? gridView.AggregateResults.Count > 1 : gridView.AggregateResults.Count > 0,
                            ShowGroupFooters = gridView.IsGrouping && gridView.AggregateResults.Count > 1,
                            ShowColumnHeaders = true
                        });

                gridView.ElementExporting -= ElementExporting;

                memoryStream.Position = 0;
                document = new HtmlFormatProvider().Import(memoryStream);
                document.SectionDefaultPageOrientation = TheExportOptionsViewModel.Value.PageOrientation;
            }

            return document;
        }
Example #47
0
 public CustomKeyboardCommandProvider(GridViewDataControl dataControl)
     : base(dataControl)
 {
     _dataControl = dataControl;
 }
Example #48
0
        private static RadDocument CreateDocument(GridViewDataControl grid, PrintSettings settings)
        {
            RadDocument document;

            using (var stream = new MemoryStream())
            {
                EventHandler<GridViewElementExportingEventArgs> elementExporting = (s, e) =>
                {
                    switch (e.Element)
                    {
                        case ExportElement.Table:
                            e.Attributes["border"] = "0";
                            break;
                        case ExportElement.HeaderRow:
                            e.Styles.Add("background-color", settings.HeaderBackground.ToString().Remove(1, 2));
                            break;
                        case ExportElement.GroupHeaderRow:
                            e.Styles.Add("background-color", settings.GroupHeaderBackground.ToString().Remove(1, 2));
                            break;
                        case ExportElement.Row:
                            e.Styles.Add("background-color", settings.RowBackground.ToString().Remove(1, 2));
                            break;
                    }
                };

                grid.ElementExporting += elementExporting;

                grid.Export(stream, new GridViewExportOptions
                    {
                        Format = Telerik.Windows.Controls.ExportFormat.Html,
                        ShowColumnFooters = grid.ShowColumnFooters,
                        ShowColumnHeaders = grid.ShowColumnHeaders,
                        ShowGroupFooters = grid.ShowGroupFooters
                    });

                grid.ElementExporting -= elementExporting;

                stream.Position = 0;

                document = new HtmlFormatProvider().Import(stream);
            }

            return document;
        }
        /// <summary>
        /// Adds new functions providing undefined value and invalidates existing functions.
        /// </summary>
        /// <param name="grid">The grid control.</param>
        /// <param name="aggregateDefinitions">The aggregate definition collection.</param>
        public static void AddOrInvalidateAggregateFunctions(GridViewDataControl grid, IList<AggregateDefinition> aggregateDefinitions)
        {
            var resultList = aggregateDefinitions.Select(
                aggregateDefinition => new AggregateResult
                {
                    ColumnName = aggregateDefinition.ColumnName, 
                    SummaryType = aggregateDefinition.SummaryType, 
                    Value = Constants.AggregateCalculatingPlaceHolder.ToString()
                }).ToList();

            var resultCollection = new AggregateResultCollection(resultList);

            UpdateAggregates(grid, resultCollection, aggregateDefinitions);
        }
Example #50
0
        private static Workbook CreateWorkBook(GridViewDataControl grid)
        {
            Workbook book;

            using (var stream = new MemoryStream())
            {
                grid.Export(stream, new GridViewExportOptions
                    {
                        Format = Telerik.Windows.Controls.ExportFormat.Csv,
                        ShowColumnFooters = grid.ShowColumnFooters,
                        ShowColumnHeaders = grid.ShowColumnHeaders,
                        ShowGroupFooters = grid.ShowGroupFooters,
                    });

                stream.Position = 0;

                book = new CsvFormatProvider().Import(stream);
            }

            return book;
        }
 public KeyboardCommandProvider(GridViewDataControl grid)
     : base(grid)
 {
     this.parentGrid = grid;
 }