/// <summary>
        /// Converts the <paramref name="orientation"/> given to a proper page rotation angle, in degrees.
        /// </summary>
        /// <param name="orientation">Page orientation.</param>
        /// <returns>Rotation angle.</returns>
        public static int GetRotationAngle(PageOrientation orientation)
        {
            int angle = 0;

            switch (orientation)
            {
                case PageOrientation.None:
                case PageOrientation.Portrait:
                case PageOrientation.PortraitUp:
                    angle = 90;
                    break;
                case PageOrientation.PortraitDown:
                    angle = 270;
                    break;
                case PageOrientation.Landscape:
                case PageOrientation.LandscapeLeft:
                    angle = 0;
                    break;
                case PageOrientation.LandscapeRight:
                    angle = 180;
                    break;
            }

            return angle;
        }

        private void RotateIamgeViewer(PageOrientation orientation)
        {
            var duration = new Duration(TimeSpan.FromSeconds(0.5));
            var sb = new Storyboard();
            sb.Duration = duration;

            var da = new DoubleAnimation();
            da.Duration = duration;

            sb.Children.Add(da);
            //Storyboard.SetTarget(da, mediaViewerTranform);
            Storyboard.SetTarget(da, mediaViewerTransform);
            Storyboard.SetTargetProperty(da, new PropertyPath("Rotation"));

            if (orientation == PageOrientation.Landscape ||
                orientation == PageOrientation.LandscapeLeft ||
                orientation == PageOrientation.LandscapeRight)
            {
                da.From = 90;
                da.To = 0;
            }
            else if (orientation == PageOrientation.Portrait ||
                orientation == PageOrientation.PortraitDown ||
                orientation == PageOrientation.PortraitUp)
            {
                da.From = -90;
                da.To = 0;
            }
            sb.Begin();
        }

 public ThreadView()
 {
     InitializeComponent();
     BindEvents();
     this.SupportedOrientations = SupportedPageOrientation.PortraitOrLandscape;
     this._currentOrientation = this.Orientation;
     this._defaultAppBar = this.ApplicationBar;
 }

        public ExportSettings()
        {
            m_page_orientation = PageOrientation.Landscape;
            if (GetTotalScreens() > 1)
                m_template_doc_path = Directory.GetParent(Assembly.GetExecutingAssembly().Location) + "\\Documents\\Template Landscape.docx";
            else
                m_template_doc_path = Directory.GetParent(Assembly.GetExecutingAssembly().Location) + "\\Documents\\Template Portrait.docx";

        }

        public static void SetOrientation(this PhoneApplicationPage page, PageOrientation? orientation = null)
        {
            var app = Resolver.Resolve<IXFormsApp>() as XFormsAppWP;

            if (app != null)
            {
                app.SetOrientation(orientation ?? page.Orientation);
            }
        }

        //PdfPage m_page;
        //public PdfPrintTarget(PdfPage page)
        //{
        //    m_page = page;
        //}

        /*
        #region IPrintTarget Members

        public float Width
        {
            get { return PageSizeConverter.ToSize(m_page.Size).Width; }
        }

        public float Height
        {
            get { return PageSizeConverter.ToSize(m_page.Size).Height; }
        }

        #endregion
        */

        #region IPrintTarget Members

        public SizeF GetPageSize(PageOrientation orientation)
        {
            switch (orientation)
            {
                case PageOrientation.Portrait:
                    return new SizeF(m_size.Width, m_size.Height);
                case PageOrientation.Landscape:
                    return new SizeF(m_size.Height, m_size.Width);
            }
            throw new Exception("The method or operation is not implemented.");
        }

        // Constructor
        public MainPage()
        {
            InitializeComponent();
            var locator = new ViewModelLocator();
            _mainViewModel = locator.Main;
            DataContext = _mainViewModel;

            OrientationChanged += MainPageOrientationChanged;
            _lastOrientation = Orientation;

            UpdateOrientation();
        }

        private void SetOrientation(PageOrientation orientation)
        {
            switch (orientation)
            {
                case PageOrientation.Landscape:

                case PageOrientation.LandscapeLeft:

                case PageOrientation.LandscapeRight:

                case PageOrientation.None:
                    TopMenu.Visibility = System.Windows.Visibility.Collapsed;
                    break;
                case PageOrientation.Portrait:

                case PageOrientation.PortraitDown:

                case PageOrientation.PortraitUp:
                    TopMenu.Visibility = System.Windows.Visibility.Visible;
                    break;
                default:
                    break;
            }

            switch (orientation)
            {
                case PageOrientation.Landscape:

                    break;
                case PageOrientation.LandscapeLeft:
                    ContentPanel.Margin = new Thickness(0, 0, 75, 0);
                    IndexNav.Margin = new Thickness(0, 0, 75, 0);
                    break;
                case PageOrientation.LandscapeRight:
                    ContentPanel.Margin = new Thickness(75, 0, 0, 0);
                    IndexNav.Margin = new Thickness(75, 0, 0, 0);
                    break;
                case PageOrientation.None:


                case PageOrientation.Portrait:

                case PageOrientation.PortraitDown:

                case PageOrientation.PortraitUp:


                default:
                    ContentPanel.Margin = new Thickness(0, 0, 0, 0);
                    IndexNav.Margin = new Thickness(0, 0, 0, 0);
                    break;
            }
        }

        void determineStyle(PageOrientation newOrientation, IList<ResourceDictionary> resources)
        {
            var lastOrientation = state;
            state = newOrientation;

            //some flags to simplify detecting an orientation change
            var wasBlank = (lastOrientation == null ||
                            lastOrientation == PageOrientation.None);
            var wasPortrait = (lastOrientation == PageOrientation.Portrait ||
                               lastOrientation == PageOrientation.PortraitDown ||
                               lastOrientation == PageOrientation.PortraitUp);
            var wasLandscape = (lastOrientation == PageOrientation.Landscape ||
                                lastOrientation == PageOrientation.LandscapeLeft ||
                                lastOrientation == PageOrientation.LandscapeRight);
            var isPortrait = (newOrientation == PageOrientation.Portrait ||
                              newOrientation == PageOrientation.PortraitDown ||
                              newOrientation == PageOrientation.PortraitUp);
            var isLandscape = (newOrientation == PageOrientation.Landscape ||
                               newOrientation == PageOrientation.LandscapeLeft ||
                               newOrientation == PageOrientation.LandscapeRight);


            //STYLE SWITCHING

            //only switch on orientation change
            if (isLandscape && (wasBlank || wasPortrait))
            {
                //clear existing responsive styles if any
                removeExistingStyles(resources);

                //add compact style xaml to resources
                if (this.LandscapeStyles != null)
                {
                    foreach (var style in this.LandscapeStyles)
                        resources.Add(style);
                }

            }
            else if (isPortrait && (wasBlank || wasLandscape))
            {
                //clear existing responsive styles if any
                removeExistingStyles(resources);

                //add regular style xaml to resources
                if (this.PortraitStyles != null)
                {
                    foreach (var style in this.PortraitStyles)
                        resources.Add(style);
                }

            }
        }

        void handleChangeEvents(Size size, PageOrientation orientation)
        {
            if (ResponsiveMethods == null)
                return;

            foreach (var method in ResponsiveMethods)
            {
                method.HandleChange(size,
                                    orientation,
                                    this.Resources.MergedDictionaries);
            }

        }

        /// <summary>
        /// Tells the Viewfinder to update its UI to reflect a new PageOrientation
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void OnOrientationChanged(PageOrientation newOrientation)
        {
            if (IsPortrait(newOrientation))
            {
                this.rotateArrowButtonToPortrait.Begin();
            }
            else
            {
                this.rotateArrowButtonToLandscape.Begin();
            }

            ApplyRotation();
        }

 public PdfSharpExporter(int nLayoutStartIndex, int nLayoutEndIndex, string sExportFile, string sPageOrientation)
     : base(nLayoutStartIndex, nLayoutEndIndex)
 {
     m_sExportFile = sExportFile;
     try
     {
         m_ePageOrientation = (PageOrientation)Enum.Parse(typeof(PageOrientation), sPageOrientation);
     }
     catch (Exception)
     {
         Logger.AddLogLine(sPageOrientation + " is an unknow page orientation.");
     }
     m_zDocument = new PdfDocument();
     AddPage();
 }

		private void AdjustForOrientation(PageOrientation orientation)
		{
			Messenger.Default.Send<OrientationChangedMessage>(new OrientationChangedMessage { Orientation = orientation });
			lastKnownOrientation = orientation;

			if (LayoutRoot != null)
			{
				if (orientation == PageOrientation.LandscapeRight)
					LayoutRoot.Margin = new Thickness(40, 0, 0, 0);
				else if (orientation == PageOrientation.LandscapeLeft)
					LayoutRoot.Margin = new Thickness(0, 0, 35, 0);
				else
					LayoutRoot.Margin = new Thickness(0, 0, 0, 0);
			}
		}

 private void SetRotation(PageOrientation orientation)
 {
     if (orientation.HasFlag(PageOrientation.LandscapeLeft))
     {
         BufferRotate = 0;
     }
     else if (orientation.HasFlag(PageOrientation.LandscapeRight))
     {
         BufferRotate = 180;
     }
     else if (orientation.HasFlag(PageOrientation.PortraitUp))
     {
         //The back camera renders upsidedown so use a different rotate
         if (Capture != null && Capture.SensorLocation == CameraSensorLocation.Front)
         {
             BufferRotate = 270;
         }
         else if (Capture != null && Capture.SensorLocation == CameraSensorLocation.Back)
         {
             BufferRotate = 90;
         }
         else
         {
             BufferRotate = 270;
         }
     }
     else if (orientation.HasFlag(PageOrientation.PortraitDown))
     {
         //The back camera renders upsidedown so use a different rotate
         if (Capture != null && Capture.SensorLocation == CameraSensorLocation.Front)
         {
             BufferRotate = 90;
         }
         else if (Capture != null && Capture.SensorLocation == CameraSensorLocation.Back)
         {
             BufferRotate = 270;
         }
         else
         {
             BufferRotate = 90;
         }
     }
     if (Preview != null)
     {
         Preview.Rotate(BufferRotate);
     }
 }

        public static CompositeTransform GetCameraTransformByOrientation(CameraType cameraType, PageOrientation orientation)
        {
            var scaleX = 1;
            var scaleY = 1;
            var rotation = 0;

            if (cameraType == CameraType.FrontFacing)
            {
                scaleX = -1;
                if (orientation == PageOrientation.LandscapeRight)
                {
                    rotation = 180;
                }
                else if (orientation == PageOrientation.LandscapeLeft)
                {
                }
                else if (orientation == PageOrientation.PortraitUp)
                {
                    rotation = 90;
                }
            }
            else
            {
                if (orientation == PageOrientation.LandscapeRight)
                {
                    scaleX = -1;
                    scaleY = -1;
                }
                else if (orientation == PageOrientation.LandscapeLeft)
                {
                    // all good
                }
                else if (orientation == PageOrientation.PortraitUp)
                {
                    rotation = 90;
                }
            }

            return new CompositeTransform
            {
                CenterX = 0.5, 
                CenterY = 0.5, 
                ScaleX = scaleX, 
                ScaleY = scaleY, 
                Rotation = rotation 
            };
        }

 private static DisplayOrientations ConvertToNativeOrientation(PageOrientation xamlOrientation)
 {
     switch (xamlOrientation)
     {
         case PageOrientation.Portrait:
         case PageOrientation.PortraitUp:
             return DisplayOrientations.Portrait;
         case PageOrientation.PortraitDown:
             return DisplayOrientations.PortraitFlipped;
         case PageOrientation.Landscape:
         case PageOrientation.LandscapeLeft:
             return DisplayOrientations.Landscape;
         case PageOrientation.LandscapeRight:
             return DisplayOrientations.LandscapeFlipped;
         default:
             return DisplayOrientations.Landscape;
     }
 }

        public void ReloadPreview(PageOrientation pageOrientation, PaperSize currentPaper)
        {
            ReloadingPreview = true;
            if (FullScreenPrintWindow != null)
            {
                WaitScreen.Show("Loading Preview");
            }
            
            if (PageOrientation == PageOrientation.Portrait)
            {
                FlowDocument.PageHeight = currentPaper.Height;
                FlowDocument.PageWidth = currentPaper.Width;
            }
            else
            {
                FlowDocument.PageHeight = currentPaper.Width;
                FlowDocument.PageWidth = currentPaper.Height;
            }

	        var s = new FileStream("c:\\aa.xps", FileMode.OpenOrCreate, FileAccess.ReadWrite);
			_ms = new MemoryStream();
            _pkg = Package.Open(s, FileMode.Create, FileAccess.ReadWrite);
            //const string pack = "pack://temp.xps";
            //var oldPackage = PackageStore.GetPackage(new Uri(pack));
            //if (oldPackage == null)
            //    PackageStore.AddPackage(new Uri(pack), _pkg);
            //else
            //{
            //    PackageStore.RemovePackage(new Uri(pack));
            //    PackageStore.AddPackage(new Uri(pack), _pkg);
            //}
            _xpsDocument = new XpsDocument(_pkg);//, CompressionOption.SuperFast, pack);
            var xpsWriter = XpsDocument.CreateXpsDocumentWriter(_xpsDocument);

            var documentPaginator = ((IDocumentPaginatorSource)FlowDocument).DocumentPaginator;
            xpsWriter.Write(documentPaginator);
            Paginator = documentPaginator;
            MaxCopies = NumberOfPages = ApproaxNumberOfPages = Paginator.PageCount;
            PagesAcross = 2;
            DisplayPagePreviewsAll(documentPaginator);
            WaitScreen.Hide();
            ReloadingPreview = false;
        }

        private void MainPage_OrientationChanged(object sender, OrientationChangedEventArgs e)
        {
            var newOrientation = e.Orientation;
            // Orientations are (clockwise) 'PortraitUp', 'LandscapeRight', 'LandscapeLeft'

            var transitionElement = new RotateTransition();
            switch (newOrientation)
            {
                case PageOrientation.Landscape:
                case PageOrientation.LandscapeRight:
                    // Come here from PortraitUp (i.e. clockwise) or LandscapeLeft?
                    transitionElement.Mode = _lastOrientation == PageOrientation.PortraitUp
                        ? RotateTransitionMode.In90Counterclockwise
                        : RotateTransitionMode.In180Clockwise;
                    break;
                case PageOrientation.LandscapeLeft:
                    // Come here from LandscapeRight or PortraitUp?
                    transitionElement.Mode = _lastOrientation == PageOrientation.LandscapeRight
                        ? RotateTransitionMode.In180Counterclockwise
                        : RotateTransitionMode.In90Clockwise;
                    break;
                case PageOrientation.Portrait:
                case PageOrientation.PortraitUp:
                    // Come here from LandscapeLeft or LandscapeRight?
                    transitionElement.Mode = _lastOrientation == PageOrientation.LandscapeLeft
                        ? RotateTransitionMode.In90Counterclockwise
                        : RotateTransitionMode.In90Clockwise;
                    break;
            }

            // Execute the transition
            var phoneApplicationPage =
                (PhoneApplicationPage) (((PhoneApplicationFrame) Application.Current.RootVisual)).Content;
            var transition = transitionElement.GetTransition(phoneApplicationPage);
            transition.Completed += delegate
            {
                transition.Stop();
            };
            transition.Begin();

            _lastOrientation = newOrientation;
        }

 private static bool IsLandscape(PageOrientation orientation)
 {
     return orientation == PageOrientation.Landscape || orientation == PageOrientation.LandscapeLeft || orientation == PageOrientation.LandscapeRight;
 }

        private void OnOrientationChanged(object sender, OrientationChangedEventArgs e)
        {
            PageOrientation newOrientation = e.Orientation;

            RotateTransition transitionElement = new RotateTransition();

            // Adjust padding if possible
            
            if (null != MainGrid)
            {
                switch (newOrientation)
                {
                    case PageOrientation.Portrait:
                    case PageOrientation.PortraitUp:
                        HeaderTitle.Margin = new Thickness(20, 12, 12, 12);
                        Picker.Margin = new Thickness(8, 12, 0, 0);

                        transitionElement.Mode = (lastOrientation == PageOrientation.LandscapeLeft) ?
                        RotateTransitionMode.In90Counterclockwise : RotateTransitionMode.In90Clockwise;

                        break;
                    case PageOrientation.Landscape:
                    case PageOrientation.LandscapeLeft:
                        HeaderTitle.Margin = new Thickness(72, 0, 0, 0);
                        Picker.Margin = new Thickness(60, 0, 0, 0);

                        transitionElement.Mode = (lastOrientation == PageOrientation.LandscapeRight) ?
                        RotateTransitionMode.In180Counterclockwise : RotateTransitionMode.In90Clockwise;
                        break;
                    case PageOrientation.LandscapeRight:
                        HeaderTitle.Margin = new Thickness(20, 0, 0, 0);
                        Picker.Margin = new Thickness(8, 0, 0, 0);

                        transitionElement.Mode = (lastOrientation == PageOrientation.PortraitUp) ? 
                        RotateTransitionMode.In90Counterclockwise : RotateTransitionMode.In180Clockwise;
                        break;
                }
            }

            PhoneApplicationPage phoneApplicationPage = (PhoneApplicationPage)(((PhoneApplicationFrame)Application.Current.RootVisual)).Content;
            ITransition transition = transitionElement.GetTransition(phoneApplicationPage);
            transition.Completed += delegate
            {
                transition.Stop();
            };
            transition.Begin();

            lastOrientation = newOrientation;
        }