inabox/inabox.wpf/Reports/PreviewWindow.xaml.cs

using System.IO;
using System.Windows;
using System.Windows.Controls;
using FastReport;
using FastReport.Design;
using FastReport.Design.StandardDesigner;
using FastReport.Export;
using FastReport.Export.BIFF8;
using FastReport.Export.Html;
using FastReport.Export.Image;
using FastReport.Export.Pdf;
using FastReport.Export.RichText;
using FastReport.Export.Text;
using InABox.Clients;
using InABox.Core;
using InABox.WPF;
using Button = System.Windows.Controls.Button;
using Image = System.Windows.Controls.Image;
using SaveFileDialog = Microsoft.Win32.SaveFileDialog;
using System;
using InABox.Wpf;
using TextBox = System.Windows.Controls.TextBox;
using InABox.Core.Reports;
using ICSharpCode.AvalonEdit.Highlighting;
using System.Drawing;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace InABox.Wpf.Reports
{
    /// <summary>
    ///     Interaction logic for PreviewWindow.xaml
    /// </summary>
    public partial class PreviewWindow : ThemableWindow
    {
        private Report _report;
        private readonly ReportTemplate _template;
        private readonly DataModel _model;
        private bool modelIsPopulated;

        public Action<ReportTemplate>? SaveTemplate { get; set; } = null;

        public PreviewWindow(ReportTemplate template, DataModel model)
        {
            InitializeComponent();

            _template = template;
            _model = model;
            modelIsPopulated = false;

            PrintButton.Content = ImageUtils.CreatePreviewWindowButtonContent("Print",Wpf.Resources.print);
            SaveButton.Content = ImageUtils.CreatePreviewWindowButtonContent("Save",Wpf.Resources.save);
            foreach (var def in ReportUtils.ExportDefinitions)
            {
                var button = new Button();
                if (def.Control != null)
                    button.Content = def.Control;
                else
                    button.Content = GetImage(def.Image);

                button.VerticalAlignment = VerticalAlignment.Top;
                button.Click += (o, e) =>
                {
                    var data = ExportReport(def.Type);
                    def.Action.Invoke(model, data);
                };
                Toolbar.Items.Insert(Toolbar.Items.IndexOf(ExportSeparator), button);
            }

            //EmailButton.Content = GetImage(Wpf.Resources.email);
            FirstButton.Content = ImageUtils.CreatePreviewWindowButtonContent("First",Wpf.Resources.first);
            BackButton.Content = ImageUtils.CreatePreviewWindowButtonContent("Back",Wpf.Resources.back);
            NextButton.Content = ImageUtils.CreatePreviewWindowButtonContent("Next",Wpf.Resources.next);
            LastButton.Content = ImageUtils.CreatePreviewWindowButtonContent("Last",Wpf.Resources.last);
            ZoomInButton.Content = ImageUtils.CreatePreviewWindowButtonContent("Zoom In",Wpf.Resources.zoomin);
            ZoomOutButton.Content = ImageUtils.CreatePreviewWindowButtonContent("Zoom Out",Wpf.Resources.zoomout);
            DesignButton.Content = ImageUtils.CreatePreviewWindowButtonContent("Design",Wpf.Resources.pencil);

            Loaded += PreviewWindow_Loaded;

            Editor.TextChanged += Editor_TextChanged;

            Designer.cmdPreview.CustomAction += CmdPreview_CustomAction;
            Designer.cmdSave.CustomAction += CmdSave_CustomAction;
            Designer.cmdSaveAs.CustomAction += CmdSaveAs_CustomAction;
        }

        private void CmdSaveAs_CustomAction(object? sender, EventArgs e)
        {
            var dialog = new SaveFileDialog();
            dialog.Filter = "Report files (*.frx)|*.frx";
            dialog.FileName = _template.Name + ".frx";
            if (dialog.ShowDialog() == true)
                Designer.Report.Save(dialog.FileName);
        }

        private void CmdSave_CustomAction(object? sender, EventArgs e)
        {
            SaveReport();
        }

        private void Editor_TextChanged(object? sender, EventArgs e)
        {
        }

        public bool IsPreview { get; set; } = true;
        public bool ShouldPopulate { get; set; } = true;

        public Report Report
        {
            get => _report;
            set
            {
                _report = value;
                Designer.Report = value;
                Refresh();
            }
        }

        public bool AllowDesign
        {
            get => DesignButton.Visibility == Visibility.Visible;
            set => DesignButton.Visibility = value ? Visibility.Visible : Visibility.Collapsed;
        }

        private Image GetImage(Bitmap bitmap)
        {
            return new Image
            {
                Source = bitmap.AsBitmapImage(),
                Height = 32.0F,
                Width = 32.0F,
                Margin = new Thickness(10)
            };
        }

        private void DisplayLoading()
        {
            PreviewGrid.RowDefinitions[1].Height = new GridLength(0);
            PreviewGrid.RowDefinitions[2].Height = new GridLength(1, GridUnitType.Star);
            DesignButton.IsEnabled = false;
        }
        private void CloseLoading()
        {
            PreviewGrid.RowDefinitions[1].Height = new GridLength(1, GridUnitType.Star);
            PreviewGrid.RowDefinitions[2].Height = new GridLength(0);
            DesignButton.IsEnabled = true;
        }

        private void SetupReport(Action action)
        {
            DisplayLoading();
            Task.Run(() =>
            {
                try
                {
                    if (_report == null)
                    {
                        _report = ReportUtils.SetupReport(_template, _model, ShouldPopulate && !modelIsPopulated);
                    }
                    return null;
                }
                catch (Exception e)
                {
                    return e.Message;
                }
            }).ContinueWith((s) =>
            {
                try
                {
                    if (s.Result == null)
                    {
                        if (Designer.Report == null)
                        {
                            Designer.Report = _report;
                        }
                        action();
                        CloseLoading();
                    }
                    else
                    {
                        ShowEditor(s.Result);
                    }
                }
                catch (Exception e)
                {
                    ShowEditor(e.Message);
                }
            }, TaskScheduler.FromCurrentSynchronizationContext());
        }

        private void ShowPreview()
        {
            MainGrid.RowDefinitions[0].Height = new GridLength(1, GridUnitType.Star);
            MainGrid.RowDefinitions[1].Height = new GridLength(0);
            MainGrid.RowDefinitions[2].Height = new GridLength(0);

            Title = string.Format("Report Preview - {0}", _template.Name);

            SetupReport(() => Refresh());
            /*Task.Run(() =>
            {
                try
                {
                    if(_report == null)
                    {
                        _report = ReportUtils.SetupReport(_template, _model, !modelIsPopulated);
                    }
                    return null;
                }
                catch (Exception e)
                {
                    return e.Message;
                }
            }).ContinueWith((s) =>
            {
                try
                {
                    if (s.Result == null)
                    {
                        if(Designer.Report == null)
                        {
                            Designer.Report = _report;
                        }
                        Refresh();
                    }
                    else
                    {
                        ShowEditor(s.Result);
                    }
                }
                catch (Exception e)
                {
                    ShowEditor(e.Message);
                }
            }, TaskScheduler.FromCurrentSynchronizationContext());*/
        }

        private void ShowDesigner()
        {
            MainGrid.RowDefinitions[0].Height = new GridLength(0);
            MainGrid.RowDefinitions[1].Height = new GridLength(1, GridUnitType.Star);
            MainGrid.RowDefinitions[2].Height = new GridLength(0);

            SetupReport(() =>
            {
                Title = string.Format("Report Designer - {0}", Report.FileName);
                Designer.RefreshLayout();
            });
        }

        private void CmdPreview_CustomAction(object? sender, EventArgs e)
        {
            ShowPreview();
        }

        private void ShowEditor(string err)
        {
            MainGrid.RowDefinitions[0].Height = new GridLength(0);
            MainGrid.RowDefinitions[1].Height = new GridLength(0);
            MainGrid.RowDefinitions[2].Height = new GridLength(1, GridUnitType.Star);

            Title = string.Format("Edit Report Template - {0}", _template.Name);

            Editor.Text = _report?.SaveToString() ?? (String.IsNullOrWhiteSpace(_template.RDL) ? "" : _template.RDL);
            Editor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("XML");

            System.Windows.MessageBox.Show("There was an error loading the report. The raw XML data has been loaded here.\n\nError Message:\n" + (err.Length < 200 ? err : string.Concat(err.AsSpan(0, 200), "...")));
        }

        private void PreviewWindow_Loaded(object sender, RoutedEventArgs e)
        {
            if (IsPreview)
            {
                ShowPreview();
            }
            else
            {
                ShowDesigner();
            }
        }

        private byte[] ExportReport(ReportExportType type)
        {
            var _exporters = new Dictionary<ReportExportType, ExportBase>
            {
                { ReportExportType.PDF, new PDFExport() },
                { ReportExportType.HTML, new HTMLExport() },
                { ReportExportType.RTF, new RTFExport() },
                { ReportExportType.Excel, new Excel2003Document() },
                { ReportExportType.Text, new TextExport() },
                { ReportExportType.Image, new ImageExport() }
            };
            byte[] result = null;
            using (var ms = new MemoryStream())
            {
                _report.Export(_exporters[type], ms);
                result = ms.GetBuffer();
            }

            return result;
        }

        private void Refresh()
        {
            _report.Preview = Preview;
            _report.Prepare();
            _report.ShowPrepared();
            Preview.Zoom = 1.0F;
        }

        private void PrintButton_Click(object sender, RoutedEventArgs e)
        {
            Report.PrintPrepared();
        }

        private void SaveButton_Click(object sender, RoutedEventArgs e)
        {
            var dlg = new SaveFileDialog();
            dlg.Filter = "PDF Files (*.pdf)|*.pdf";
            dlg.FileName = Path.ChangeExtension(Report.FileName, ".pdf");
            if (dlg.ShowDialog() == true)
                Report.Export(new PDFExport(), dlg.FileName);
        }


        //private void EmailButton_Click(object sender, RoutedEventArgs e)
        //{
        //    String attachment = System.IO.Path.Combine(System.IO.Path.GetTempPath(), System.IO.Path.ChangeExtension(Report.FileName,".pdf"));
        //    using (new WaitCursor())
        //    {
        //        using (var filestream = System.IO.File.Open(attachment, System.IO.FileMode.Create))
        //        {
        //            _report.Export(new PDFExport(), filestream);
        //            filestream.Close();
        //        }
        //    }

        //    //Outlook.Application outlookApp = new Outlook.Application();
        //    //Outlook.MailItem mailItem = (Outlook.MailItem)outlookApp.CreateItem(Outlook.OlItemType.olMailItem);
        //    //mailItem.Subject = System.IO.Path.ChangeExtension(Report.FileName,"");
        //    //mailItem.To = "";
        //    //mailItem.HTMLBody = "";
        //    //mailItem.Attachments.Add(attachment, Outlook.OlAttachmentType.olByValue, Type.Missing, Type.Missing);
        //    //mailItem.Display(false);

        //}

        private void FirstButton_Click(object sender, RoutedEventArgs e)
        {
            Preview.First();
        }

        private void BackButton_Click(object sender, RoutedEventArgs e)
        {
            Preview.Prior();
        }

        private void NextButton_Click(object sender, RoutedEventArgs e)
        {
            Preview.Next();
        }

        private void LastButton_Click(object sender, RoutedEventArgs e)
        {
            Preview.Last();
        }

        private void ZoomInButton_Click(object sender, RoutedEventArgs e)
        {
            Preview.ZoomIn();
        }

        private void ZoomOutButton_Click(object sender, RoutedEventArgs e)
        {
            Preview.ZoomOut();
        }

        private void SaveReport()
        {
            _template.RDL = _report.SaveToString();
            DoSave(_template);
            Designer.Report = _report;
        }

        private void DesignButton_Click(object sender, RoutedEventArgs e)
        {
            ShowDesigner();
        }

        private void ToolBar_Loaded(object sender, RoutedEventArgs e)
        {
            var toolBar = sender as ToolBar;
            var overflowGrid = toolBar.Template.FindName("OverflowGrid", toolBar) as FrameworkElement;
            if (overflowGrid != null) overflowGrid.Visibility = Visibility.Collapsed;
            var mainPanelBorder = toolBar.Template.FindName("MainPanelBorder", toolBar) as FrameworkElement;
            if (mainPanelBorder != null) mainPanelBorder.Margin = new Thickness();

            var grid = toolBar.Template.FindName("Grid", toolBar) as FrameworkElement;
            if (grid != null) grid.Margin = new Thickness();
        }

        private void DoSave(ReportTemplate template)
        {
            if (SaveTemplate is null)
                new Client<ReportTemplate>().Save(template, "Updated by Designer");
            else
                SaveTemplate?.Invoke(template);
        }

        private void SaveEditorButton_Click(object sender, RoutedEventArgs e)
        {
            _template.RDL = Editor.Text;
            DoSave(_template);
            _report = null;
            ShowPreview();
        }       
    }
}