public void OnRootChanged(Visual oldRoot, Visual newRoot)
 {
     if(_active && newRoot != null) 
     {
         Keyboard.Focus(null); // internally we will set the focus to the root. 
     } 
 }

        internal PrintPreviewWindow(
			Visual mainPrintContent,
			IEnumerable<PrintContent> additionalPrintContent,
			IViewDrawingState viewDrawingState)
        {
            _mainPrintContent = mainPrintContent;
            _additionalPrintContent = additionalPrintContent;
            _viewDrawingState = viewDrawingState;

            PrintCommand = new RelayCommand(DoPrint);

            PaperFormats = new[]
                {
                    new PaperFormatViewModel("DIN A3", PaperFormat.A3),
                    new PaperFormatViewModel("DIN A4", PaperFormat.A4),
                };
            _selectedPaperFormat = PaperFormats.ElementAt(1);

            PaperOrientations = new[]
                {
                    new PaperOrientationViewModel(MlResources.PaperOrientationPortrait, PaperOrientation.Portrait),
                    new PaperOrientationViewModel(MlResources.PaperOrientationLandscape, PaperOrientation.Landscape),
                };
            _selectedPaperOrientation = PaperOrientations.ElementAt(1);

            InitializeComponent();
        }

        public MemoryStream GenerateImage(Visual vsual, int widhth, int height, ImageFormat format)
        {
            BitmapEncoder encoder = null;

            switch (format)
            {
                case ImageFormat.JPG :
                    encoder = new JpegBitmapEncoder();
                    break;
                case ImageFormat.PNG:
                    encoder = new PngBitmapEncoder();
                    break;
                case ImageFormat.BMP:
                    encoder = new BmpBitmapEncoder();
                    break;
                case ImageFormat.GIF:
                    encoder = new GifBitmapEncoder();
                    break;
                case ImageFormat.TIF:
                    encoder = new TiffBitmapEncoder();
                    break;

            }

            if (encoder == null) return null;

            RenderTargetBitmap rtb = this.RenderVisaulToBitmap(vsual, widhth, height);
            MemoryStream file = new MemoryStream();
            encoder.Frames.Add(BitmapFrame.Create(rtb));
            encoder.Save(file);

            return file;
        }

        public void AddVisual(Visual visual)
        {
            visuals.Add(visual);

            base.AddVisualChild(visual);
            base.AddLogicalChild(visual);
        }

 /// <summary>
 /// Public constructor.
 /// </summary>
 /// <param name="visual">The visual representation of this page.</param>
 /// <param name="pageSize">The size of the page, including margins.</param>
 /// <param name="bleedBox">The bounds the ink drawn by the page.</param>
 /// <param name="contentBox">The bounds of the content within the page.</param>
 public DocumentPage(Visual visual, Size pageSize, Rect bleedBox, Rect contentBox)
 {
     _visual = visual;
     _pageSize = pageSize;
     _bleedBox = bleedBox;
     _contentBox = contentBox;
 }

        public void DeleteVisual(Visual visual)
        {
            visuals.Remove(visual);

            base.RemoveVisualChild(visual);
            base.RemoveLogicalChild(visual);
        }

 public static System.Windows.Media.Effects.BitmapEffectInput GetBitmapEffectInput(Visual reference)
 {
   Contract.Requires(reference != null);
   
   // May return null
   return default(System.Windows.Media.Effects.BitmapEffectInput);
 }

 /// <summary>
 /// Adds given visual as a root of Snoop visual tree.
 /// </summary>
 internal static void AddSnoopVisualTreeRoot(Visual root)
 {
     if (!_registeredSnoopVisualTreeRoots.Contains(root))
     {
         _registeredSnoopVisualTreeRoots.Add(root);
     }
 }

 /// <summary>
 /// Creates a VisualCollection.
 /// </summary>
 public VisualCollection(Visual parent)
 {
     if (parent == null)
     {
         throw new ArgumentNullException("parent");
     }
     _owner = parent;
 }

    public static Geometry GetClip(Visual reference)
    {
      Contract.Requires(reference != null);

      // May return null

      return default(Geometry);
    }

		static void UpdateReferences(Visual visual)
		{
			foreach (var glyph in visual.FindVisualChildren<Glyphs>())
				if (!glyph.FontUri.IsAbsoluteUri)
				{
					var glyphGuid = glyph.FontUri.ToString();
					glyph.FontUri = new Uri(ServiceFactoryBase.ContentService.GetContentFileName(glyphGuid), UriKind.Absolute);
				}
		}

        public static PopupLayer GetPopupLayer(Visual target)
        {
            if (target == null)
            {
                return null;
            }

            return target is IPopupLayerHost ? ((IPopupLayerHost)target).PopupLayer : GetPopupLayer(target.VisualParent);
        }

        public DirectPrinter(
			Visual mainPrintContent, 
			IEnumerable<PrintContent> additionalPrintContent, 
			IViewDrawingState viewDrawingState, 
			int pageMargin)
        {
            _mainPrintContent = mainPrintContent;
            _additionalPrintContent = additionalPrintContent;
            _viewDrawingState = viewDrawingState;
            _pageMargin = pageMargin;
        }

		private ModelUIElement3D CreateMeshModel(Visual visual)
		{
			var model3d = InternalResources["ElementModel"] as ModelUIElement3D;
			VisualBrush brush = new VisualBrush(visual);
			RenderOptions.SetCachingHint(brush, CachingHint.Cache);

			var geom3D = model3d.Model as GeometryModel3D;
			(geom3D.Material as DiffuseMaterial).Brush = brush;
			(geom3D.Geometry as MeshGeometry3D).Positions = CreateMeshPositions();

			return model3d;
		}

        private ModelUIElement3D CreateMeshModel(Visual visual)
        {
            GeometryModel3D model3d = (InternalResources["ElementModel"] as GeometryModel3D).Clone();
            VisualBrush brush = new VisualBrush(visual);
            RenderOptions.SetCachingHint(brush, CachingHint.Cache);
            (model3d.Material as DiffuseMaterial).Brush = brush;
            (model3d.Geometry as MeshGeometry3D).Positions = CreateMeshPositions();

            ModelUIElement3D model = new ModelUIElement3D();
            model.Model = model3d;

            return model;
        }

		private ModelUIElement3D CreateMeshModel(Visual visual)
		{
			var model3D = ((GeometryModel3D) InternalResources["ElementModel"]).Clone();
			var brush = new VisualBrush(visual);
			RenderOptions.SetCachingHint(brush, CachingHint.Cache);
            RenderOptions.SetBitmapScalingMode(brush, BitmapScalingMode.LowQuality);
			((DiffuseMaterial) model3D.Material).Brush = brush;
			((MeshGeometry3D) model3D.Geometry).Positions = CreateMeshPositions();

			var model = new ModelUIElement3D {Model = model3D};

		    return model;
		}

        public static AdornerLayer GetAdornerLayer(Visual visual)
        {
            while (visual != null)
            {
                if (visual is IAdornerLayerHost)
                {
                    return ((IAdornerLayerHost)visual).AdornerLayer;
                }

                visual = visual.VisualParent;
            }

            return null;
        }

        public static void SaveToImage(Visual visual, int width, int height)
        {
            Debug.WriteLine($"width: {width}, height: {height}");
            var filePath = ChoosePathToSave();
            if (filePath == null) return;

            using (var fs = new FileStream(filePath, FileMode.Create))
            {
                var renderer = new RenderTargetBitmap(width, height, Dpi, Dpi, PixelFormat);
                renderer.Render(visual);
                var encoder = ChooseBitmapEncoder(Path.GetExtension(filePath));
                encoder.Frames.Add(BitmapFrame.Create(renderer));
                encoder.Save(fs);
            }
            SelectFileInExplorer(filePath);
        }

        internal XpsDocumentGenerator(
			Visual mainPrintContent,
			IEnumerable<PrintContent> additionalPrintContent,
			IViewDrawingState viewDrawingState,
			int width,
			int height,
			int pageMargin)
        {
            _mainPrintContent = mainPrintContent;
            _additionalPrintContent = additionalPrintContent;
            _viewDrawingState = viewDrawingState;
            PageMargin = pageMargin;
            Width = width;
            Height = height;

            InitializeComponent();
        }

 public abstract void WriteAsync(Visual visual, PrintTicket printTicket, object userState);