using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

using pdftron;
using pdftron.PDF;
using pdftron.SDF;
using pdftron.Common;

namespace PDFViewWPFTestCS
{
    /// <summary>
    /// Interaction logic for PDFViewViewer.xaml
    /// </summary>
    public partial class PDFViewViewer : UserControl
    {
        private PDFDoc _pdfdoc = null; // currently open PDF document
        private SideWindowControl _sidecontrol;
        private GridLength _oldwidth = new GridLength(200);
        private PDFViewWPF.Selection _currentSearchSelection;
        private List<Rectangle> _onScreenSelection = new List<Rectangle>();

        private MainWindow Current_Main { get; set; }
        public PDFViewWPF Current_View { get; set; }
        public bool IsNaviOpen { get; set; }
        public double NaviWidth
        {
            get { return DocViewerGrid.ColumnDefinitions[0].Width.Value; }
            set { DocViewerGrid.ColumnDefinitions[0].Width = new GridLength(value); }
        }
        public double ZoomLevel
        {
            get { return Current_View.GetZoom(); }
            set { Current_View.SetZoom(value); }
        }
        public string _safeDocName { get; set; }

        private pdftron.PDF.Tools.ToolManager _ToolManager;
        public pdftron.PDF.Tools.ToolManager ToolManager
        {
            get { return _ToolManager; }
        }

        public PDFViewViewer(MainWindow main_window)
        {
            InitializeComponent();

            PresentationSource source = PresentationSource.FromVisual(Application.Current.MainWindow);

            double scaleFactor = 1;
            if (source != null)
            {
                scaleFactor = 1 / source.CompositionTarget.TransformFromDevice.M11;
            }

            Current_Main = main_window;

            Current_View = new PDFViewWPF();
            Current_View.PixelsPerUnitWidth = scaleFactor;
            Current_View.SetRenderedContentCacheSize(16);
            Current_View.UseLayoutRounding = true;
            _sidecontrol = new SideWindowControl();

            Current_View.SetAntiAliasing(true);
            Current_View.SetPathHinting(true);
            Current_View.SetThinLineAdjustment(true, true);
            Current_View.SetupThumbnails(false, true, true, 500, 200 * 1024 * 1024, 0.2);
            Current_View.SetProgressiveRendering(true);
            Current_View.SetProgressiveRenderingInterval(750);
            Current_View.SetPageBorderVisibility(true);

            NaviBarGrid.Children.Add(_sidecontrol);
            PDFGrid.Children.Add(Current_View);

            _ToolManager = new pdftron.PDF.Tools.ToolManager(Current_View);
            _ToolManager.ToolModeChanged += ToolManager_ToolModeChanged;
            Current_View.Loaded += _pdfviewWpf_Loaded;
			Current_View.OnSetDoc += Current_View_OnSetDoc;

            Current_View.FindTextFinished += Current_View_FindTextFinished;
            Current_View.LayoutChanged += Current_View_LayoutChanged;

            Current_View.CurrentScrollChanged += _pdfviewWpf_ScollChanged; // set zoom textbox value
            Current_View.CurrentZoomChanged += _pdfviewWpf_CurrentZoomChanged; // set zoom textbox value
            Current_View.CurrentPageNumberChanged += Current_View_CurrentPageNumberChanged;
            Current_View.SetDownloadReportHandler(OnDownload, null);

            this.KeyDown += new KeyEventHandler(OnViewKeyDown);
            this.KeyUp += new KeyEventHandler(OnViewKeyUp);

            //hide sidebar
            main_window.btn_collapse.IsEnabled = false;
            main_window.btn_expand.IsEnabled = true;
            PDFGrid.Margin = new Thickness(0);
            SideWindowSplitter.DragCompleted += SideWindowSplitter_DragCompleted;

            Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_continuous);
            Current_View.SetPageViewMode(PDFViewWPF.PageViewMode.e_fit_width);
            Current_View.SetBackgroundColor(Colors.DarkGray);
            Current_View.SetUrlExtraction(false);

            // This allows touch interaction
            Current_View.IsManipulationEnabled = true;


            this.ToolManager.SelectedAnnotationsChanged += ToolManager_SelectedAnnotationsChanged;


            Current_View.VerticalScrollBarVisibility = ScrollBarVisibility.Hidden;
            MyScrollBarOnTheSide.ValueChanged += MyScrollBarOnTheSide_ValueChanged;
        }

        private void ToolManager_SelectedAnnotationsChanged()
        {
            List<Annot> annots = ToolManager.SelectedAnnotations;
        }

        /// <summary>
        /// This will be called each time we switch to this tab, and when we first open it.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void _pdfviewWpf_Loaded(object sender, RoutedEventArgs e)
        {
            Current_Main.txtbox_pagenum.Text = Current_View.GetCurrentPage().ToString();
            Current_Main.SetZoomValue(Current_View.GetZoom());
        }
		
		/// <summary>
        /// This will happen whenever we open a new document.
        /// It is guaranteed to happen after the document is loaded and ready to be used, so we
        /// replicate it here in case there are some timing issues between the loaded handler and he document being loaded.
        /// </summary>
        /// <param name="viewer"></param>
        void Current_View_OnSetDoc(PDFViewWPF viewer)
        {
            Current_Main.txtbox_pagenum.Text = Current_View.GetCurrentPage().ToString();
            Current_Main.slider_zoom.Value = Current_View.GetZoom();
            Current_Main.SetZoomValue(Current_View.GetZoom());
            pdftron.PDF.Action open_action = viewer.GetDoc().GetOpenAction();
            if (open_action.IsValid() && open_action.GetType() == pdftron.PDF.Action.Type.e_JavaScript)
            {
                ActionParameter action_param = new ActionParameter(open_action);
                viewer.ExecuteAction(action_param);
            }
        }

        #region Events

        void ToolManager_ToolModeChanged(pdftron.PDF.Tools.ToolManager.ToolType toolType)
        {
            UpdateToolButtonStates();
        }

        public void UpdateToolButtonStates()
        {
            if (_ToolManager == null)
            {
                return;
            }

            Current_Main.t_pan.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_pan);
            Current_Main.PanToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_pan);

            Current_Main.t_annot_edit.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_annot_edit);
            Current_Main.AnnotationEditToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_annot_edit);

            Current_Main.t_text_rect.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_select_rectangular);

            Current_Main.t_text_struct.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_select);

            Current_Main.LineToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_line_create);
            Current_Main.ArrowToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_arrow_create);
            Current_Main.RectangleToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_rect_create);
            Current_Main.OvalToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_oval_create);
            Current_Main.InkToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_ink_create);
            Current_Main.TextBoxToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_annot_create);
            Current_Main.CalloutToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_callout_create);
            Current_Main.StickyNoteToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_sticky_note_create);
            Current_Main.HighlightToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_highlight);
            Current_Main.UnderlineToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_underline);
            Current_Main.StrikeoutToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_strikeout);
            Current_Main.SquigglyToolMenuItem.IsChecked = (_ToolManager.CurrentTool.ToolMode == pdftron.PDF.Tools.ToolManager.ToolType.e_text_squiggly);
        }


        void Current_View_LayoutChanged(PDFViewWPF viewer)
        {
            UpdatePresentationModeButtonStates();
            HighlightSelection();
            SyncScrollerFromViewer();
        }

        public void UpdatePresentationModeButtonStates()
        {
            Current_Main.SinglePageButton.IsChecked = false;
            Current_Main.SingleContinuousButton.IsChecked = false;
            Current_Main.FacingButton.IsChecked = false;
            Current_Main.FacingContinuousButton.IsChecked = false;
            Current_Main.FacingCoverButton.IsChecked = false;
            Current_Main.FacingCoverContinuousButton.IsChecked = false;

            switch (Current_View.GetPagePresentationMode())
            {
                case PDFViewWPF.PagePresentationMode.e_single_page:
                    Current_Main.SinglePageButton.IsChecked = true;
                    break;
                case PDFViewWPF.PagePresentationMode.e_single_continuous:
                    Current_Main.SingleContinuousButton.IsChecked = true;
                    break;
                case PDFViewWPF.PagePresentationMode.e_facing:
                    Current_Main.FacingButton.IsChecked = true;
                    break;
                case PDFViewWPF.PagePresentationMode.e_facing_continuous:
                    Current_Main.FacingContinuousButton.IsChecked = true;
                    break;
                case PDFViewWPF.PagePresentationMode.e_facing_cover:
                    Current_Main.FacingCoverButton.IsChecked = true;
                    break;
                case PDFViewWPF.PagePresentationMode.e_facing_continuous_cover:
                    Current_Main.FacingCoverContinuousButton.IsChecked = true;
                    break;
            }
        }


        void SideWindowSplitter_DragCompleted(object sender, System.Windows.Controls.Primitives.DragCompletedEventArgs e)
        {
            Current_Main.UpdateSidewindowButtons();
        }


        public void SetCurrentPage(int page)
        {
            Current_View.CurrentPageNumber = page;
            //Current_View.SetCurrentPage(page);
        }

        void _pdfviewWpf_CurrentZoomChanged(PDFViewWPF viewer)
        {
            double zoom = Current_View.GetZoom();
            Current_Main.SetZoomValue(zoom);
            HighlightSelection();
            SyncScrollerFromViewer();
        }

        void _pdfviewWpf_ScollChanged(PDFViewWPF viewer, ScrollChangedEventArgs e)
        {
            SyncScrollBarPosition();
        }

        void Current_View_CurrentPageNumberChanged(PDFViewWPF viewer, int currentPage, int totalPages)
        {
            Current_Main.txtbox_pagenum.Text = currentPage.ToString();
            HighlightSelection();
            SyncScrollerFromViewer();
        }

        void txtbox_pagenum_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter && !string.IsNullOrWhiteSpace(Current_Main.txtbox_pagenum.Text))
            {
                int pagenum;
                if (Int32.TryParse(Current_Main.txtbox_pagenum.Text, out pagenum))
                    Current_View.SetCurrentPage(pagenum);
            }
        }

        private void txtbox_zoom_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter && !string.IsNullOrWhiteSpace(Current_Main.txtbox_zoom.Text))
            {
                int newzoom;
                if (Int32.TryParse(Current_Main.txtbox_zoom.Text, out newzoom))
                    Current_View.SetZoom(newzoom / 100.0);
            }
        }

        private void OnViewKeyDown(object sender, KeyEventArgs e)
        {
            if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
            {
                if (e.Key == Key.F)
                {
                    if (Current_Main.FindTextDialog == null)
                    {
                        Current_Main.FindTextDialog = new FindTextDialog();
                        Current_Main.FindTextDialog.Owner = Current_Main;
                        Current_Main.FindTextDialog.Show();
                    }
                    else
                    {
                        Current_Main.FindTextDialog.ActivateFindText();
                    }
                }
                if (e.Key == Key.S)
                {
                    if (_pdfdoc != null && Current_View != null && (_pdfdoc.IsModified()))
                        this.Save(_pdfdoc.GetFileName());
                }
            }
        }

        void OnViewKeyUp(object sender, KeyEventArgs e)
        {

        }

        public void OpenNavibar()
        {
            DocViewerGrid.ColumnDefinitions[0].Width = new GridLength(200);

            Current_Main.btn_expand.IsEnabled = false;
            Current_Main.btn_collapse.IsEnabled = true;
            IsNaviOpen = true;
        }

        public void CloseNavibar()
        {
            _oldwidth = DocViewerGrid.ColumnDefinitions[0].Width;
            DocViewerGrid.ColumnDefinitions[0].Width = new GridLength(0);

            Current_Main.btn_collapse.IsEnabled = false;
            Current_Main.btn_expand.IsEnabled = true;
            IsNaviOpen = false;
        }

        #endregion

        #region Methods
        public bool OpenPDF(String filename)
        {
            try
            {
                try
                {
                    _pdfdoc = new PDFDoc(filename);
                }
                catch (Exception ex)
                {
                    _pdfdoc = OpenImage(filename);
                    if (_pdfdoc == null)
                        throw ex;
                }

                if (!_pdfdoc.InitSecurityHandler())
                {
                    MessageBox.Show("Document authentication error", "PDFViewWPF Error");
                    return false;
                }
                Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_continuous);
                Current_View.SetPageViewMode(PDFViewWPF.PageViewMode.e_fit_width);
                Current_View.SetUrlExtraction(false);

                if (_pdfdoc.GetPageCount() > 2000)
                {
                    Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_page);
                }
                Current_View.SetDoc(_pdfdoc);
                _sidecontrol.CreateSideWindow(Current_View, _ToolManager);
            }
            catch (PDFNetException ex)
            {
                MessageBox.Show(ex.Message);
                return false;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
                return false;
            }

            return true;
        }

        // A utility function used to display other images types besides PDF (TIF, JPEG, BMG,PNG, etc)
        public PDFDoc OpenImage(string filename)
        {
            try
            {
                PDFDoc pdfDoc = new PDFDoc();
                ElementBuilder f = new ElementBuilder();
                ElementWriter writer = new ElementWriter();

                pdftron.PDF.Page page = pdfDoc.PageCreate();
                writer.Begin(page);

                // Add image to the document
                pdftron.PDF.Image img = pdftron.PDF.Image.Create(pdfDoc, filename);

                pdftron.PDF.Rect imgBox = new pdftron.PDF.Rect(0, 0, img.GetImageWidth(), img.GetImageHeight());
                pdftron.PDF.Rect scaledBox = new pdftron.PDF.Rect();
                double scaleFactor;
                if (imgBox.Height() / imgBox.Width() > 792 / 612)
                    scaleFactor = imgBox.Height() / 792;
                else
                    scaleFactor = imgBox.Width() / 612;
                scaledBox.x2 = imgBox.x2 / scaleFactor;
                scaledBox.y2 = imgBox.y2 / scaleFactor;

                // set crop and media box of this page to fit with the scaled image 
                page.SetCropBox(scaledBox);
                page.SetMediaBox(scaledBox);

                // create the image element and add it to the page 
                int width = (int)scaledBox.Width();
                int height = (int)scaledBox.Height();
                int offsetX = 0;
                int offsetY = 0;

                Element element = f.CreateImage(img, new Matrix2D(width, 0, 0, height, offsetX, offsetY));
                writer.WritePlacedElement(element);
                writer.End(); // Finish writing to the page 

                pdfDoc.PagePushBack(page);
                return pdfDoc;
            }
            catch (Exception)
            {
                return null;
            }
        }

        public bool OpenURL(String url, String password)
        {
            try
            {
                // Open a PDF file at the given url. This works best with PDF's that
	            // are linearized, as pages can be downloaded and viewed in random access order,
	            // without the need to download the entire document. A viewing session can also be
	            // persisted across multiple viewing/application sessions to remove redundant downloads 
	            // and improve overall performance by using the optional cache_file parameter.
                _ToolManager.IsEnabled = false;
                Current_View.OpenURLAsync(url, "", password);
            }
            catch (PDFNetException ex)
            {
                _ToolManager.IsEnabled = true;
                MessageBox.Show(ex.Message);
                return false;
            }
            catch (Exception ex)
            {
                _ToolManager.IsEnabled = true;
                MessageBox.Show(ex.ToString());
                return false;
            }
            return true;
        }

        public PDFDoc GetPDFDoc()
        {
            if (_pdfdoc == null) return null;
            else return Current_View.GetDoc();
        }

        public void SetPageViewMode(PDFViewWPF.PageViewMode mode)
        {
            Current_View.SetPageViewMode(mode);
        }

        public PDFViewWPF.PageViewMode GetPageViewMode()
        {
            return Current_View.GetPageViewMode();
        }

        public void FitPage()
        {
            Current_View.SetPageViewMode(PDFViewWPF.PageViewMode.e_fit_page);
        }

        public void FitWidth()
        {
            Current_View.SetPageViewMode(PDFViewWPF.PageViewMode.e_fit_width);
        }

        public double GetZoom()
        {
            return Current_View.GetZoom();
        }

        public void SetZoom(double zoom)
        {
            Current_View.SetZoom(zoom);
        }

        public void ZoomIn()
        {
            Current_View.SetZoom(Current_View.GetZoom() * 1.25);
        }

        public void ZoomOut()
        {
            Current_View.SetZoom(Current_View.GetZoom() / 1.25);
        }

        public int GetCurrentPageNumber()
        {
            return Current_View.GetCurrentPage();
        }

        public void FirstPage()
        {
            Current_View.GotoFirstPage();
        }

        public void PrevPage()
        {
            Current_View.GotoPreviousPage();
        }

        public void NextPage()
        {
            Current_View.GotoNextPage();
        }

        public void LastPage()
        {
            Current_View.GotoLastPage();
        }

        public void PageSingle()
        {
            Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_page);
        }

        public void PageSingleContinuous()
        {
            Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_continuous);
        }

        public void PageFacingContinuous()
        {
            Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_facing_continuous);
        }

        public void PageFacing()
        {
            Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_facing);
        }

        public void PageFacingCover()
        {
            Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_facing_cover);
        }

        public void PageFacingCoverContinous()
        {
            Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_facing_continuous_cover);
        }

        public void RotateClockwise()
        {
            Current_View.RotateClockwise();
            Current_View.UpdatePageLayout();
            Current_View.Update();
        }

        public void RotateCounterClockwise()
        {
            Current_View.RotateCounterClockwise();
            //Current_View.UpdatePageLayout();
            //Current_View.Update();
        }

        public pdftron.PDF.Page.Rotate GetRotation()
        {
            return Current_View.GetRotation();
        }

        public void SetAntiAliasing(bool anti_alias)
        {
            Current_View.SetAntiAliasing(anti_alias);
            Current_View.Update();
        }

        public void SetRasterizer(bool built_in)
        {
            if (built_in)
                Current_View.SetRasterizerType(PDFRasterizer.Type.e_BuiltIn);
            else
                Current_View.SetRasterizerType(PDFRasterizer.Type.e_GDIPlus);

            Current_View.Update();
        }

        public void SetSmoothImages(bool smooth_images)
        {
            Current_View.SetImageSmoothing(smooth_images);
            Current_View.Update();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="filename">The path to save the file to</param>
        /// <param name="force">true if we should save, whether or not it is modified</param>
        public void Save(string filename, bool force = false)
        {
            if (_pdfdoc == null) return;

            System.IO.FileInfo fi = new System.IO.FileInfo(filename);
            if (fi.Exists && fi.IsReadOnly)
            {
                MessageBox.Show("This is a read only file. Please choose Save As and enter a new file name to save.", "Error during the Save");
                return;
            }

            bool locked = false;
            try
            {
                bool shouldSave = force;
                if (!shouldSave)
                {
                    Current_View.DocLock(true);
                    locked = true;
                    if (_pdfdoc.IsModified())
                    {
                        Current_View.DocUnlock();
                        locked = false;
						shouldSave = true;
                    }
                }
                if (shouldSave)
                {
                    Current_View.CancelRendering();
                    _pdfdoc.Save(filename, pdftron.SDF.SDFDoc.SaveOptions.e_incremental);
                }

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(), "Error during the Save");
            }
            finally
            {
                if (locked)
                {
                    Current_View.DocUnlock();
                }
            }
        }

        public string SaveAs()
        {
            if (_pdfdoc != null && Current_View != null)
            {
                Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
                dlg.Filter = "PDF Files (*.pdf)|*.pdf|All Files (*.*)|*.*";
                dlg.DefaultExt = ".pdf";
                dlg.FileName = _pdfdoc.GetFileName();

                if (dlg.ShowDialog() == true)
                {
                    this.Save(dlg.FileName);
                    return dlg.SafeFileName;
                }
            }
            return null;
        }

        public bool CloseFile()
        {
            if (_pdfdoc != null && Current_View != null && _pdfdoc.IsModified())
            {
                string messageBoxText = "Would you like to save changes to " + _safeDocName + "?";
                string caption = "PDFViewWPF";
                MessageBoxButton button = MessageBoxButton.YesNoCancel;
                MessageBoxImage icon = MessageBoxImage.Question;
                MessageBoxResult defaultResult = MessageBoxResult.Yes;
                MessageBoxOptions options = MessageBoxOptions.DefaultDesktopOnly;

                MessageBoxResult result;
                result = MessageBox.Show(messageBoxText, caption, button, icon, defaultResult, options);

                if (result == MessageBoxResult.Yes)
                {
                    this.Save(_pdfdoc.GetFileName());
                    Dispose();
                    return true;
                }
                else if (result == MessageBoxResult.No)
                {
                    Dispose();
                    return true;
                }
                else
                    return false;
            }
            else
            {
                Dispose();
                return true;
            }
        }

        public void Dispose()
        {
            Current_View.CloseDoc();
            Current_View.Dispose();
            if(_pdfdoc != null) _pdfdoc.Dispose();
        }

        public void Activate()
        {
            Current_View.Activate();
            _sidecontrol.Activate();
        }

        public void Deactivate()
        {
            Current_View.Deactivate();
            _sidecontrol.Deactivate();
        }

        //public void SetToolMode(PDFViewWPF.ToolMode tool_mode)
        //{
        //    Current_View.SetToolMode(tool_mode);
        //}

        public void CopySelectedText()
        {
            Current_View.CopySelectedTextToClipboardAsUnicode();
        }

        public void SelectAll()
        {
            _ToolManager.CurrentTool.SelectAll();
        }

        public void DeselectAll()
        {
            _ToolManager.CurrentTool.DeselectAll();
        }

        public void FindText(string str, bool match_case, bool match_whole_word, bool search_up, bool reg_exp)
        {
            Current_View.FindText(str, match_case, match_whole_word, search_up, reg_exp); // Use the build in Find text dialog.
        }


        void Current_View_FindTextFinished(PDFViewWPF viewer, bool found, PDFViewWPF.Selection selection)
        {
            Current_Main.FindTextFinishedHandler(viewer, found, selection);
            _currentSearchSelection = selection;
            HighlightSelection();
            viewer.ClearSelection();
            _ToolManager.ClearSelectedTextHighlighting();
        }

        /// <summary>
        /// Highlights the search result if any
        /// </summary>
        /// <param name="result">A text selection acquired by mPDFView.FindText</param>
        /// <returns>true if and only if the selections contains at least one highlight</returns>
        private bool HighlightSelection()
        {
            ClearSearchSelection();
            if (_currentSearchSelection == null)
            {
                return false;
            }

            double[] quads = _currentSearchSelection.GetQuads();
            int numQuads = quads.Length / 8;
            int pageNumber = _currentSearchSelection.GetPageNum();
            int quadNumber = 0;
            int[] visiblePages = Current_View.GetVisiblePages();
            if (!visiblePages.Contains(pageNumber))
            {
                return false;
            }

            List<System.Windows.Rect> rects = new List<System.Windows.Rect>();

            // get highlights in control (screen) space
            for (int i = 0; i < numQuads; i++)
            {
                quadNumber = i * 8;
                double x1 = quads[quadNumber + 0];
                double y1 = quads[quadNumber + 1];

                double x2 = quads[quadNumber + 2];
                double y2 = quads[quadNumber + 3];

                double x3 = quads[quadNumber + 4];
                double y3 = quads[quadNumber + 5];

                double x4 = quads[quadNumber + 6];
                double y4 = quads[quadNumber + 7];

                Current_View.ConvPagePtToScreenPt(ref x1, ref y1, pageNumber);
                Current_View.ConvPagePtToScreenPt(ref x2, ref y2, pageNumber);
                Current_View.ConvPagePtToScreenPt(ref x3, ref y3, pageNumber);
                Current_View.ConvPagePtToScreenPt(ref x4, ref y4, pageNumber);

                double left, right, top, bottom;

                left = Math.Min(x1, Math.Min(x2, Math.Min(x3, x4)));
                right = Math.Max(x1, Math.Max(x2, Math.Max(x3, x4)));
                top = Math.Min(y1, Math.Min(y2, Math.Min(y3, y4)));
                bottom = Math.Max(y1, Math.Max(y2, Math.Max(y3, y4)));

                rects.Add(new System.Windows.Rect(left, top, right - left, bottom - top));
            }

            Canvas annotCanvas = Current_View.GetCanvas();

            // add highlight(s) to annotation canvas
            foreach (System.Windows.Rect rect in rects)
            {
                Rectangle highlight = new Rectangle();
                highlight.Fill = new SolidColorBrush() { Color = Colors.Blue };
                highlight.Fill.Opacity = 0.3;
                highlight.Width = rect.Width;
                highlight.Height = rect.Height;
                Canvas.SetLeft(highlight, rect.Left + Current_View.GetHScrollPos());
                Canvas.SetTop(highlight, rect.Top + Current_View.GetVScrollPos());
                annotCanvas.Children.Add(highlight);
                _onScreenSelection.Add(highlight);
            }

            return numQuads > 0;
        }

        /// <summary>
        /// Removes the rectangles highlighting the selection, but keeps the selection for future reference
        /// to be used with HighlightSelection
        /// </summary>
        /// <param name="deleteSelection">If true, will also delete the underlaying selection</param>
        public void ClearSearchSelection(bool deleteSelection = false)
        {
            foreach (Rectangle rect in _onScreenSelection)
            {
                Canvas parent = rect.Parent as Canvas;
                if (parent != null)
                {
                    parent.Children.Remove(rect);
                }
            }
            if (deleteSelection)
            {
                _currentSearchSelection = null;
            }
        }

        public int GetPageCount()
        {
            return Current_View.GetPageCount();
        }

        private void OnDownload(DownloadedType type, Int32 page_num, Int32 obj_num, String msg, Object obj)
        {
            switch (type)
            {
                case DownloadedType.e_opened:
                    // e_opened indicates that we have a valid, but incomplete PDFDoc.
                    _pdfdoc = Current_View.GetDoc();
                    if (_pdfdoc.GetPageCount() > 2000)
                    {
                        Current_View.SetPagePresentationMode(PDFViewWPF.PagePresentationMode.e_single_page);
                    }
                    _sidecontrol.CreateSideWindow(Current_View, _ToolManager);
                    // the PDF should be treated as read only, and only simple functions
                    // should be called on the doc, until e_finished has been called.
                    break;
                case DownloadedType.e_page:
                    // this indicates the entire page is downloaded and it is safe to modify.
                    // for example add a new annotation
                    break;
                case DownloadedType.e_finished:
                    // we now have the full PDF file and it can be treated like any other
                    _ToolManager.IsEnabled = true;
                    if (MessageBox.Show("Download complete, would you like to save the PDF locally?",
                        "PDF Downloaded", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                    {
                        SaveAs();
                    }
                    break;
                case DownloadedType.e_failed:
                    // downloading has stopped if this occurs
                    _ToolManager.IsEnabled = true;
                    MessageBox.Show(msg);
                    Current_Main.CloseViewer(this);
                    break;
            }
        }

        #endregion


        #region ScrollbarSyncing

        private enum SyncingOriginators
        {
            none,
            viewer,
            scroller,
        }

        private SyncingOriginators _SyncingOriginator = SyncingOriginators.none;

        private void SyncScrollerFromViewer()
        {
            if (_SyncingOriginator == SyncingOriginators.none)
            {
                _SyncingOriginator = SyncingOriginators.scroller;
                try
                {
                    SetUpScrollableHeight();
                    SyncScrollBarPosition();
                }
                catch (Exception)
                { }
                finally
                {
                    _SyncingOriginator = SyncingOriginators.none;
                }
            }
        }

        private void SetUpScrollableHeight()
        {
            MyScrollBarOnTheSide.Minimum = 0;
            double canvasHeight = Current_View.GetCanvas().Height;
            double viewHeight = Current_View.ActualHeight;
            if (!double.IsNaN(canvasHeight) && !double.IsNaN(viewHeight))
            {
                MyScrollBarOnTheSide.ViewportSize = viewHeight;
                MyScrollBarOnTheSide.Maximum = canvasHeight - viewHeight;
            }
            else
            {
                MyScrollBarOnTheSide.ViewportSize = 0;
                MyScrollBarOnTheSide.Maximum = 0;
            }
        }

        private void SyncScrollBarPosition()
        {
            SyncingOriginators entryOriginator = _SyncingOriginator;
            if (_SyncingOriginator != SyncingOriginators.scroller)
            {
                _SyncingOriginator = SyncingOriginators.viewer;
                try
                {
                    MyScrollBarOnTheSide.Value = Current_View.GetVScrollPos();
                }
                catch (Exception)
                { }
                finally
                {
                    _SyncingOriginator = entryOriginator;
                }
            }
        }

        void MyScrollBarOnTheSide_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            if (_SyncingOriginator == SyncingOriginators.none)
            {
                _SyncingOriginator = SyncingOriginators.scroller;
                try
                {
                    Current_View.SetVScrollPos(MyScrollBarOnTheSide.Value);
                }
                catch (Exception)
                { }
                finally
                {
                    _SyncingOriginator = SyncingOriginators.none;
                }
            }
        }

        #endregion ScrollbarSyncing


    }
}