Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Framework / System / Windows / Controls / FlowDocumentReader.cs / 1305600 / FlowDocumentReader.cs
//----------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//---------------------------------------------------------------------------
using System; // Object
using System.Collections; // IEnumerator
using System.Collections.ObjectModel; // ReadOnlyCollection
using System.Security; // SecurityCritical
using System.Windows.Automation.Peers; // AutomationPeer
using System.Windows.Data; // BindingOperations
using System.Windows.Controls.Primitives; // PlacementMode
using System.Windows.Documents; // FlowDocument
using System.Windows.Input; // KeyEventArgs
using System.Windows.Media; // ScaleTransform, VisualTreeHelper
using System.Windows.Markup; // IAddChild
using System.Windows.Threading; // Dispatcher
using MS.Internal; // Invariant, DoubleUtil
using MS.Internal.Commands; // CommandHelpers
using MS.Internal.Controls; // EmptyEnumerator
using MS.Internal.Documents; // FindToolBar
using MS.Internal.KnownBoxes; // BooleanBoxes
using MS.Internal.AppModel; // IJournalState
namespace System.Windows.Controls
{
///
/// FlowDocumentReader provides a full user experience for consuming text content.
/// It will be used as the default viewer for loose XAML or containers that contain
/// text content, and can be styled and re-used by developers for use within their applications.
///
[TemplatePart(Name = "PART_ContentHost", Type = typeof(Decorator))]
[TemplatePart(Name = "PART_FindToolBarHost", Type = typeof(Decorator))]
[ContentProperty("Document")]
public class FlowDocumentReader : Control, IAddChild, IJournalState
{
//-------------------------------------------------------------------
//
// Constructors
//
//-------------------------------------------------------------------
#region Constructors
///
/// Static Constructor
///
static FlowDocumentReader()
{
DefaultStyleKeyProperty.OverrideMetadata(
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(new ComponentResourceKey(typeof(PresentationUIStyleResources), "PUIFlowDocumentReader")));
_dType = DependencyObjectType.FromSystemTypeInternal(typeof(FlowDocumentReader));
TextBoxBase.SelectionBrushProperty.OverrideMetadata(typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(new PropertyChangedCallback(UpdateCaretElement)));
TextBoxBase.SelectionOpacityProperty.OverrideMetadata(typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(new PropertyChangedCallback(UpdateCaretElement)));
CreateCommandBindings();
EventManager.RegisterClassHandler(typeof(FlowDocumentReader), Keyboard.KeyDownEvent, new KeyEventHandler(KeyDownHandler), true);
}
///
/// Default Constructor
///
public FlowDocumentReader()
: base()
{
}
#endregion Constructors
//--------------------------------------------------------------------
//
// Public Methods
//
//-------------------------------------------------------------------
#region Public Methods
///
/// Build Visual tree
///
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
// Initialize ContentHost.
// If old ContentHost is enabled, disable it first to ensure appropriate cleanup.
if (CurrentViewer != null)
{
DetachViewer(CurrentViewer);
_contentHost.Child = null;
}
_contentHost = GetTemplateChild(_contentHostTemplateName) as Decorator;
if (_contentHost != null)
{
if (_contentHost.Child != null)
{
throw new NotSupportedException(SR.Get(SRID.FlowDocumentReaderDecoratorMarkedAsContentHostMustHaveNoContent));
}
SwitchViewingModeCore(ViewingMode);
}
// Initialize FindTooBar host.
// If old FindToolBar is enabled, disable it first to ensure appropriate cleanup.
if (FindToolBar != null)
{
ToggleFindToolBar(false);
}
_findToolBarHost = GetTemplateChild(_findToolBarHostTemplateName) as Decorator;
_findButton = GetTemplateChild(_findButtonTemplateName) as ToggleButton;
}
///
/// Whether the master page can be moved to the specified page.
///
/// Page number.
public bool CanGoToPage(int pageNumber)
{
bool canGoToPage = false;
if (CurrentViewer != null)
{
canGoToPage = CurrentViewer.CanGoToPage(pageNumber);
}
return canGoToPage;
}
///
/// Invokes the Find Toolbar. This is analogous to the ApplicationCommands.Find.
///
public void Find()
{
OnFindCommand();
}
///
/// Invokes the Print Dialog. This is analogous to the ApplicationCommands.Print.
///
public void Print()
{
OnPrintCommand();
}
///
/// Cancels current printing job. This is analogous to the ApplicationCommands.CancelPrint.
///
public void CancelPrint()
{
OnCancelPrintCommand();
}
///
/// Increases the current zoom.
///
public void IncreaseZoom()
{
OnIncreaseZoomCommand();
}
///
/// Decreases the current zoom.
///
public void DecreaseZoom()
{
OnDecreaseZoomCommand();
}
///
/// Switches the current viewing mode. This is analogous to the SwitchViewingModeCommand.
///
/// Viewing mode.
public void SwitchViewingMode(FlowDocumentReaderViewingMode viewingMode)
{
OnSwitchViewingModeCommand(viewingMode);
}
#endregion Public Methods
//--------------------------------------------------------------------
//
// Public Properties
//
//--------------------------------------------------------------------
#region Public Properties
///
/// ViewingMode of FlowDocumentReader.
///
public FlowDocumentReaderViewingMode ViewingMode
{
get { return (FlowDocumentReaderViewingMode)GetValue(ViewingModeProperty); }
set { SetValue(ViewingModeProperty, value); }
}
///
/// Text Selection (readonly)
///
public TextSelection Selection
{
get
{
TextSelection result = null;
IFlowDocumentViewer viewer;
if (_contentHost != null)
{
viewer = _contentHost.Child as IFlowDocumentViewer;
if(viewer != null)
{
result = viewer.TextSelection as TextSelection;
}
}
return result;
}
}
///
/// Whether Page view can be enabled or not.
///
public bool IsPageViewEnabled
{
get { return (bool)GetValue(IsPageViewEnabledProperty); }
set { SetValue(IsPageViewEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// Whether TwoPage view can be enabled or not.
///
public bool IsTwoPageViewEnabled
{
get { return (bool)GetValue(IsTwoPageViewEnabledProperty); }
set { SetValue(IsTwoPageViewEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// Whether Scroll view can be enabled or not.
///
public bool IsScrollViewEnabled
{
get { return (bool)GetValue(IsScrollViewEnabledProperty); }
set { SetValue(IsScrollViewEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// The number of pages currently available for viewing. This value
/// is updated as content is paginated, and will change dramatically
/// when the content is resized, or edited.
///
public int PageCount
{
get { return (int)GetValue(PageCountProperty); }
}
///
/// The one-based page number of the page being displayed. If there is no content,
/// this value will be 0.
///
public int PageNumber
{
get { return (int)GetValue(PageNumberProperty); }
}
///
/// Whether the viewer can move the master page to the previous page.
///
public bool CanGoToPreviousPage
{
get { return (bool)GetValue(CanGoToPreviousPageProperty); }
}
///
/// Whether the viewer can advance the master page to the next page.
///
public bool CanGoToNextPage
{
get { return (bool)GetValue(CanGoToNextPageProperty); }
}
///
/// Is find function enabled or not
///
public bool IsFindEnabled
{
get { return (bool)GetValue(IsFindEnabledProperty); }
set { SetValue(IsFindEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// Is print function enabled or not
///
public bool IsPrintEnabled
{
get { return (bool)GetValue(IsPrintEnabledProperty); }
set { SetValue(IsPrintEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// A Property representing a content of this FlowDocumentScrollViewer.
///
public FlowDocument Document
{
get { return (FlowDocument)GetValue(DocumentProperty); }
set { SetValue(DocumentProperty, value); }
}
///
/// The Zoom applied to all pages; this value is 100-based.
///
public double Zoom
{
get { return (double)GetValue(ZoomProperty); }
set { SetValue(ZoomProperty, value); }
}
///
/// The maximum allowed value of the Zoom property.
///
public double MaxZoom
{
get { return (double)GetValue(MaxZoomProperty); }
set { SetValue(MaxZoomProperty, value); }
}
///
/// The minimum allowed value of the Zoom property.
///
public double MinZoom
{
get { return (double)GetValue(MinZoomProperty); }
set { SetValue(MinZoomProperty, value); }
}
///
/// The amount the Zoom property is incremented or decremented when
/// the IncreaseZoom or DecreaseZoom command is executed.
///
public double ZoomIncrement
{
get { return (double)GetValue(ZoomIncrementProperty); }
set { SetValue(ZoomIncrementProperty, value); }
}
///
/// Whether the viewer can increase the current zoom.
///
public bool CanIncreaseZoom
{
get { return (bool)GetValue(CanIncreaseZoomProperty); }
}
///
/// Whether the viewer can decrease the current zoom.
///
public bool CanDecreaseZoom
{
get { return (bool)GetValue(CanDecreaseZoomProperty); }
}
///
///
public Brush SelectionBrush
{
get { return (Brush)GetValue(SelectionBrushProperty); }
set { SetValue(SelectionBrushProperty, value); }
}
///
///
public double SelectionOpacity
{
get { return (double)GetValue(SelectionOpacityProperty); }
set { SetValue(SelectionOpacityProperty, value); }
}
#region Public Dynamic Properties
///
///
public static readonly DependencyProperty ViewingModeProperty =
DependencyProperty.Register(
"ViewingMode",
typeof(FlowDocumentReaderViewingMode),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
FlowDocumentReaderViewingMode.Page,
FrameworkPropertyMetadataOptions.AffectsMeasure,
new PropertyChangedCallback(ViewingModeChanged)),
new ValidateValueCallback(IsValidViewingMode));
///
///
public static readonly DependencyProperty IsPageViewEnabledProperty =
DependencyProperty.Register(
"IsPageViewEnabled",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
BooleanBoxes.TrueBox,
new PropertyChangedCallback(ViewingModeEnabledChanged)));
///
///
public static readonly DependencyProperty IsTwoPageViewEnabledProperty =
DependencyProperty.Register(
"IsTwoPageViewEnabled",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
BooleanBoxes.TrueBox,
new PropertyChangedCallback(ViewingModeEnabledChanged)));
///
///
public static readonly DependencyProperty IsScrollViewEnabledProperty =
DependencyProperty.Register(
"IsScrollViewEnabled",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
BooleanBoxes.TrueBox,
new PropertyChangedCallback(ViewingModeEnabledChanged)));
///
///
private static readonly DependencyPropertyKey PageCountPropertyKey =
DependencyProperty.RegisterReadOnly(
"PageCount",
typeof(int),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(0));
///
///
public static readonly DependencyProperty PageCountProperty = PageCountPropertyKey.DependencyProperty;
///
///
private static readonly DependencyPropertyKey PageNumberPropertyKey =
DependencyProperty.RegisterReadOnly(
"PageNumber",
typeof(int),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(0));
///
///
public static readonly DependencyProperty PageNumberProperty = PageNumberPropertyKey.DependencyProperty;
///
///
private static readonly DependencyPropertyKey CanGoToPreviousPagePropertyKey =
DependencyProperty.RegisterReadOnly(
"CanGoToPreviousPage",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(BooleanBoxes.FalseBox));
///
///
public static readonly DependencyProperty CanGoToPreviousPageProperty = CanGoToPreviousPagePropertyKey.DependencyProperty;
///
///
private static readonly DependencyPropertyKey CanGoToNextPagePropertyKey =
DependencyProperty.RegisterReadOnly(
"CanGoToNextPage",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(BooleanBoxes.FalseBox));
///
///
public static readonly DependencyProperty CanGoToNextPageProperty = CanGoToNextPagePropertyKey.DependencyProperty;
///
///
public static readonly DependencyProperty IsFindEnabledProperty =
DependencyProperty.Register(
"IsFindEnabled",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
BooleanBoxes.TrueBox,
new PropertyChangedCallback(IsFindEnabledChanged)));
///
///
public static readonly DependencyProperty IsPrintEnabledProperty =
DependencyProperty.Register(
"IsPrintEnabled",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
BooleanBoxes.TrueBox,
new PropertyChangedCallback(IsPrintEnabledChanged)));
///
///
public static readonly DependencyProperty DocumentProperty =
DependencyProperty.Register(
"Document",
typeof(FlowDocument),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
null,
new PropertyChangedCallback(DocumentChanged)));
///
///
public static readonly DependencyProperty ZoomProperty =
FlowDocumentPageViewer.ZoomProperty.AddOwner(
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
100d,
new PropertyChangedCallback(ZoomChanged),
new CoerceValueCallback(CoerceZoom)));
///
///
public static readonly DependencyProperty MaxZoomProperty =
FlowDocumentPageViewer.MaxZoomProperty.AddOwner(
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
200d,
new PropertyChangedCallback(MaxZoomChanged),
new CoerceValueCallback(CoerceMaxZoom)));
///
///
public static readonly DependencyProperty MinZoomProperty =
FlowDocumentPageViewer.MinZoomProperty.AddOwner(
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
80d,
new PropertyChangedCallback(MinZoomChanged)));
///
///
public static readonly DependencyProperty ZoomIncrementProperty =
FlowDocumentPageViewer.ZoomIncrementProperty.AddOwner(
typeof(FlowDocumentReader));
///
///
private static readonly DependencyPropertyKey CanIncreaseZoomPropertyKey =
DependencyProperty.RegisterReadOnly(
"CanIncreaseZoom",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(BooleanBoxes.TrueBox));
///
///
public static readonly DependencyProperty CanIncreaseZoomProperty = CanIncreaseZoomPropertyKey.DependencyProperty;
///
///
private static readonly DependencyPropertyKey CanDecreaseZoomPropertyKey =
DependencyProperty.RegisterReadOnly(
"CanDecreaseZoom",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(BooleanBoxes.TrueBox));
///
///
public static readonly DependencyProperty CanDecreaseZoomProperty = CanDecreaseZoomPropertyKey.DependencyProperty;
///
///
public static readonly DependencyProperty SelectionBrushProperty =
TextBoxBase.SelectionBrushProperty.AddOwner(typeof(FlowDocumentReader));
///
///
public static readonly DependencyProperty SelectionOpacityProperty =
TextBoxBase.SelectionOpacityProperty.AddOwner(typeof(FlowDocumentReader));
#endregion Public Dynamic Properties
#endregion Public Properties
//-------------------------------------------------------------------
//
// Public Commands
//
//--------------------------------------------------------------------
#region Public Commands
///
/// Switch ViewingMode command
///
public static readonly RoutedUICommand SwitchViewingModeCommand = new RoutedUICommand(SR.Get(SRID.SwitchViewingMode), "SwitchViewingMode", typeof(FlowDocumentReader), null);
#endregion
//-------------------------------------------------------------------
//
// Protected Methods
//
//-------------------------------------------------------------------
#region Protected Methods
///
/// Called when print has been completed.
///
protected virtual void OnPrintCompleted()
{
if (_printInProgress)
{
_printInProgress = false;
// Since _printInProgress value is used to determine CanExecute state, we must invalidate that state.
CommandManager.InvalidateRequerySuggested();
}
}
///
/// Handler for the Find command
///
protected virtual void OnFindCommand()
{
if (CanShowFindToolBar)
{
// Toggle on the FindToolBar between visible and hidden state.
ToggleFindToolBar(FindToolBar == null);
}
}
///
/// Handler for the Print command.
///
protected virtual void OnPrintCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.Print();
}
}
///
/// Handler for the CancelPrint command.
///
protected virtual void OnCancelPrintCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.CancelPrint();
}
}
///
/// Handler for the IncreaseZoom command.
///
protected virtual void OnIncreaseZoomCommand()
{
// If can zoom in, increase zoom by the zoom increment value.
if (CanIncreaseZoom)
{
SetCurrentValueInternal(ZoomProperty, Math.Min(Zoom + ZoomIncrement, MaxZoom));
}
}
///
/// Handler for the DecreaseZoom command.
///
protected virtual void OnDecreaseZoomCommand()
{
// If can zoom out, decrease zoom by the zoom increment value.
if (CanDecreaseZoom)
{
SetCurrentValueInternal(ZoomProperty, Math.Max(Zoom - ZoomIncrement, MinZoom));
}
}
///
/// Handler for the SwitchViewingMode command.
///
/// Viewing mode.
protected virtual void OnSwitchViewingModeCommand(FlowDocumentReaderViewingMode viewingMode)
{
SwitchViewingModeCore(viewingMode);
}
///
/// Called when IsInitialized is set to true.
///
/// Event arguments
protected override void OnInitialized(EventArgs e)
{
base.OnInitialized(e);
// Defer the Is*ViewEnabled & ViewingMode conflict exception.
// Otherwise
/// Creates AutomationPeer (
protected override AutomationPeer OnCreateAutomationPeer()
{
return new FlowDocumentReaderAutomationPeer(this);
}
///
/// An event reporting that the IsKeyboardFocusWithin property changed.
///
protected override void OnIsKeyboardFocusWithinChanged(DependencyPropertyChangedEventArgs e)
{
base.OnIsKeyboardFocusWithinChanged(e);
// In order to enable selection rendering and other similar services, the embedded viewer
// needs to get focus, when any part of the control gets focused.
// But if the focus is within the Document, do not change it. Otherwise it
// will interfere with input handling inside the Document.
if (IsKeyboardFocusWithin && CurrentViewer != null)
{
bool isFocusWithinDocument = IsFocusWithinDocument();
if (!isFocusWithinDocument)
{
((FrameworkElement)CurrentViewer).Focus();
}
}
}
///
/// This is the method that responds to the KeyDown event.
///
/// Event arguments
///
/// Critical: get_SearchUp is defined in a non-APTCA assembly.
/// TreatAsSafe: call to get_SearchUp does not entail any risk.
///
[SecurityCritical, SecurityTreatAsSafe]
protected override void OnKeyDown(KeyEventArgs e)
{
if (e.Handled) { return; }
switch (e.Key)
{
// Esc -- Close FindToolBar
case Key.Escape:
if (FindToolBar != null)
{
ToggleFindToolBar(false);
e.Handled = true;
}
break;
// F3 -- Invoke Find
case Key.F3:
if (CanShowFindToolBar)
{
if (FindToolBar != null)
{
// If the Shift key is also pressed, then search up.
FindToolBar.SearchUp = ((e.KeyboardDevice.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift);
OnFindInvoked(this, EventArgs.Empty);
}
else
{
// Make the FindToolBar visible
ToggleFindToolBar(true);
}
e.Handled = true;
}
break;
}
// If not handled, do default handling.
if (!e.Handled)
{
base.OnKeyDown(e);
}
}
#endregion Protected Methods
//-------------------------------------------------------------------
//
// Protected Properties
//
//--------------------------------------------------------------------
#region Protected Properties
///
/// Returns enumerator to logical children.
///
protected internal override IEnumerator LogicalChildren
{
get
{
if (HasLogicalChildren && Document != null)
{
return new SingleChildEnumerator(Document);
}
return EmptyEnumerator.Instance;
}
}
#endregion Protected Properties
//-------------------------------------------------------------------
//
// Internal Methods
//
//--------------------------------------------------------------------
#region Internal Methods
///
/// Allows FrameworkElement to augment the EventRoute.
///
internal override bool BuildRouteCore(EventRoute route, RoutedEventArgs args)
{
// Do not add intermediate ContentElements to the route,
// because they were added by embedded viewer.
return BuildRouteCoreHelper(route, args, false);
}
#endregion Internal Methods
//--------------------------------------------------------------------
//
// Private Methods
//
//-------------------------------------------------------------------
#region Private Methods
///
/// Handler for the SwitchViewingMode command.
///
/// Viewing mode.
protected virtual void SwitchViewingModeCore(FlowDocumentReaderViewingMode viewingMode)
{
ITextSelection textSelection = null;
ContentPosition contentPosition = null;
IFlowDocumentViewer viewer;
FrameworkElement feViewer;
bool isKeyboardFocusWithin;
DependencyObject focusedElement = null;
if (_contentHost != null)
{
// Remember the current keyboard focus state.
isKeyboardFocusWithin = IsKeyboardFocusWithin;
// Detach old viewer
viewer = _contentHost.Child as IFlowDocumentViewer;
if (viewer != null)
{
// Remember focused element, if the focus is within the Document.
// After switching to a different viewer, this focus needs to be restored.
if (isKeyboardFocusWithin)
{
bool isFocusWithinDocument = IsFocusWithinDocument();
if (isFocusWithinDocument)
{
focusedElement = Keyboard.FocusedElement as DependencyObject;
}
}
// Retrieve the current viewing state from the old viewer.
textSelection = viewer.TextSelection;
contentPosition = viewer.ContentPosition;
// Detach old viewer
DetachViewer(viewer);
}
viewer = GetViewerFromMode(viewingMode);
feViewer = (FrameworkElement)viewer;
if (viewer != null)
{
// Attach new viewer
_contentHost.Child = feViewer;
AttachViewer(viewer);
// Restore viewing state.
viewer.TextSelection = textSelection;
viewer.ContentPosition = contentPosition;
// Bring the focus to previously focused element within the document
// or to the current viewer.
if (isKeyboardFocusWithin)
{
if (focusedElement is UIElement)
{
((UIElement)focusedElement).Focus();
}
else if (focusedElement is ContentElement)
{
((ContentElement)focusedElement).Focus();
}
else
{
feViewer.Focus();
}
}
}
// Viewer changes invalidates following properties:
// - PageCount
// - PageNumber
// - CanGoToPreviousPage
// - CanGoToNextPage
UpdateReadOnlyProperties(true, true);
}
}
///
/// Determines whether focus is within Document.
///
private bool IsFocusWithinDocument()
{
DependencyObject focusedElement = Keyboard.FocusedElement as DependencyObject;
while (focusedElement != null && focusedElement != Document)
{
// Skip elements in the control's template (if such exists) and
// walk up logical tree to find if the focused element is within
// the document.
FrameworkElement fe = focusedElement as FrameworkElement;
if (fe != null && fe.TemplatedParent != null)
{
focusedElement = fe.TemplatedParent;
}
else
{
focusedElement = LogicalTreeHelper.GetParent(focusedElement);
}
}
return (focusedElement != null);
}
///
/// The Document has changed and needs to be updated.
///
private void DocumentChanged(FlowDocument oldDocument, FlowDocument newDocument)
{
// Cleanup state associated with the old document.
if (oldDocument != null)
{
// If Document was added to logical tree before, remove it.
if (_documentAsLogicalChild)
{
RemoveLogicalChild(oldDocument);
}
}
// If FlowDocumentReader was created through style, then do not modify
// the logical tree. Instead, set "core parent" for the Document.
if (TemplatedParent != null && newDocument != null && LogicalTreeHelper.GetParent(newDocument) != null)
{
// Set the "core parent" back to us.
ContentOperations.SetParent(newDocument, this);
_documentAsLogicalChild = false;
}
else
{
_documentAsLogicalChild = true;
}
// Initialize state associated with the new document.
if (newDocument != null)
{
// If Document should be part of DocumentViewer's logical tree, add it.
if (_documentAsLogicalChild)
{
AddLogicalChild(newDocument);
}
}
// Attach document to the current viewer.
if (CurrentViewer != null)
{
CurrentViewer.SetDocument(newDocument);
}
// Document invalidation invalidates following properties:
// - PageCount
// - PageNumber
// - CanGoToPreviousPage
// - CanGoToNextPage
UpdateReadOnlyProperties(true, true);
// Update the toolbar with our current document state.
if (!CanShowFindToolBar)
{
// Disable FindToolBar, if the content does not support it.
if (FindToolBar != null)
{
ToggleFindToolBar(false);
}
}
// Document is also represented as Automation child. Need to invalidate peer to force update.
FlowDocumentReaderAutomationPeer peer = UIElementAutomationPeer.FromElement(this) as FlowDocumentReaderAutomationPeer;
if (peer != null)
{
peer.InvalidatePeer();
}
}
///
/// Detach embedded viewer form the reader control.
///
private void DetachViewer(IFlowDocumentViewer viewer)
{
Invariant.Assert(viewer != null && viewer is FrameworkElement);
FrameworkElement feViewer = (FrameworkElement)viewer;
// Clear property bindings.
BindingOperations.ClearBinding(feViewer, ZoomProperty);
BindingOperations.ClearBinding(feViewer, MaxZoomProperty);
BindingOperations.ClearBinding(feViewer, MinZoomProperty);
BindingOperations.ClearBinding(feViewer, ZoomIncrementProperty);
// Unregister event handlers.
viewer.PageCountChanged -= new EventHandler(OnPageCountChanged);
viewer.PageNumberChanged -= new EventHandler(OnPageNumberChanged);
viewer.PrintStarted -= new EventHandler(OnViewerPrintStarted);
viewer.PrintCompleted -= new EventHandler(OnViewerPrintCompleted);
// Clear TemplatedParent
//feViewer._templatedParent = null;
// Detach document
viewer.SetDocument(null);
}
///
/// Attach embedded viewer to the reader control.
///
private void AttachViewer(IFlowDocumentViewer viewer)
{
Invariant.Assert(viewer != null && viewer is FrameworkElement);
FrameworkElement feViewer = (FrameworkElement)viewer;
// Set document
viewer.SetDocument(Document);
// Set TemplatedParent
//feViewer._templatedParent = TemplatedParent;
// Register event handlers.
viewer.PageCountChanged += new EventHandler(OnPageCountChanged);
viewer.PageNumberChanged += new EventHandler(OnPageNumberChanged);
viewer.PrintStarted += new EventHandler(OnViewerPrintStarted);
viewer.PrintCompleted += new EventHandler(OnViewerPrintCompleted);
// Create property bindings.
CreateTwoWayBinding(feViewer, ZoomProperty, "Zoom");
CreateTwoWayBinding(feViewer, MaxZoomProperty, "MaxZoom");
CreateTwoWayBinding(feViewer, MinZoomProperty, "MinZoom");
CreateTwoWayBinding(feViewer, ZoomIncrementProperty, "ZoomIncrement");
}
///
/// Create two way property binding.
///
private void CreateTwoWayBinding(FrameworkElement fe, DependencyProperty dp, string propertyPath)
{
Binding binding = new Binding(propertyPath);
binding.Mode = BindingMode.TwoWay;
binding.Source = this;
fe.SetBinding(dp, binding);
}
///
/// Determines whether can switch to specified ViewingMode or not.
///
private bool CanSwitchToViewingMode(FlowDocumentReaderViewingMode mode)
{
bool canSwitch = false;
switch (mode)
{
case FlowDocumentReaderViewingMode.Page:
canSwitch = IsPageViewEnabled;
break;
case FlowDocumentReaderViewingMode.TwoPage:
canSwitch = IsTwoPageViewEnabled;
break;
case FlowDocumentReaderViewingMode.Scroll:
canSwitch = IsScrollViewEnabled;
break;
}
return canSwitch;
}
///
/// Retrieves viewer form specified ViewingMode.
///
private IFlowDocumentViewer GetViewerFromMode(FlowDocumentReaderViewingMode mode)
{
IFlowDocumentViewer viewer = null;
switch (mode)
{
case FlowDocumentReaderViewingMode.Page:
if (_pageViewer == null)
{
_pageViewer = new ReaderPageViewer();
_pageViewer.SetResourceReference(StyleProperty, PageViewStyleKey);
_pageViewer.Name = "PageViewer";
CommandManager.AddPreviewCanExecuteHandler(_pageViewer, new CanExecuteRoutedEventHandler(PreviewCanExecuteRoutedEventHandler));
}
viewer = _pageViewer;
break;
case FlowDocumentReaderViewingMode.TwoPage:
if (_twoPageViewer == null)
{
_twoPageViewer = new ReaderTwoPageViewer();
_twoPageViewer.SetResourceReference(StyleProperty, TwoPageViewStyleKey);
_twoPageViewer.Name = "TwoPageViewer";
CommandManager.AddPreviewCanExecuteHandler(_twoPageViewer, new CanExecuteRoutedEventHandler(PreviewCanExecuteRoutedEventHandler));
}
viewer = _twoPageViewer;
break;
case FlowDocumentReaderViewingMode.Scroll:
if (_scrollViewer == null)
{
_scrollViewer = new ReaderScrollViewer();
_scrollViewer.SetResourceReference(StyleProperty, ScrollViewStyleKey);
_scrollViewer.Name = "ScrollViewer";
CommandManager.AddPreviewCanExecuteHandler(_scrollViewer, new CanExecuteRoutedEventHandler(PreviewCanExecuteRoutedEventHandler));
}
viewer = _scrollViewer;
break;
}
return viewer;
}
///
/// Update values for readonly properties.
///
/// Whether PageCount has been changed.
/// Whether PageNumber has been changed.
private void UpdateReadOnlyProperties(bool pageCountChanged, bool pageNumberChanged)
{
if (pageCountChanged)
{
SetValue(PageCountPropertyKey, (CurrentViewer != null) ? CurrentViewer.PageCount : 0);
}
if (pageNumberChanged)
{
SetValue(PageNumberPropertyKey, (CurrentViewer != null) ? CurrentViewer.PageNumber : 0);
SetValue(CanGoToPreviousPagePropertyKey, (CurrentViewer != null) ? CurrentViewer.CanGoToPreviousPage : false);
}
if (pageCountChanged || pageNumberChanged)
{
SetValue(CanGoToNextPagePropertyKey, (CurrentViewer != null) ? CurrentViewer.CanGoToNextPage : false);
}
}
///
/// Event handler for IFlowDocumentViewer.PageCountChanged.
///
private void OnPageCountChanged(object sender, EventArgs e)
{
Invariant.Assert(CurrentViewer != null && sender == CurrentViewer);
UpdateReadOnlyProperties(true, false);
}
///
/// Event handler for IFlowDocumentViewer.PageNumberChanged.
///
private void OnPageNumberChanged(object sender, EventArgs e)
{
Invariant.Assert(CurrentViewer != null && sender == CurrentViewer);
UpdateReadOnlyProperties(false, true);
}
///
/// Event handler for IFlowDocumentViewer.PrintStarted.
///
private void OnViewerPrintStarted(object sender, EventArgs e)
{
Invariant.Assert(CurrentViewer != null && sender == CurrentViewer);
_printInProgress = true;
// Since _printInProgress value is used to determine CanExecute state, we must invalidate that state.
CommandManager.InvalidateRequerySuggested();
}
///
/// Event handler for IFlowDocumentViewer.PrintCompleted.
///
private void OnViewerPrintCompleted(object sender, EventArgs e)
{
Invariant.Assert(CurrentViewer != null && sender == CurrentViewer);
OnPrintCompleted();
}
///
/// Convert object value to FlowDocumentReaderViewingMode.
///
private bool ConvertToViewingMode(object value, out FlowDocumentReaderViewingMode mode)
{
bool success;
if (value is FlowDocumentReaderViewingMode)
{
mode = (FlowDocumentReaderViewingMode)value;
success = true;
}
else if (value is String)
{
String str = (String)value;
if (str == FlowDocumentReaderViewingMode.Page.ToString())
{
mode = FlowDocumentReaderViewingMode.Page;
success = true;
}
else if (str == FlowDocumentReaderViewingMode.TwoPage.ToString())
{
mode = FlowDocumentReaderViewingMode.TwoPage;
success = true;
}
else if (str == FlowDocumentReaderViewingMode.Scroll.ToString())
{
mode = FlowDocumentReaderViewingMode.Scroll;
success = true;
}
else
{
mode = FlowDocumentReaderViewingMode.Page;
success = false;
}
}
else
{
mode = FlowDocumentReaderViewingMode.Page;
success = false;
}
return success;
}
///
/// Enables/disables the FindToolBar.
///
/// Whether to enable/disable FindToolBar.
private void ToggleFindToolBar(bool enable)
{
Invariant.Assert(enable == (FindToolBar == null));
// Command event for toggle button is only fired in OnClick - Therefore we just need to change the state
if(_findButton != null && _findButton.IsChecked.HasValue && _findButton.IsChecked.Value != enable)
{
_findButton.IsChecked = enable;
}
DocumentViewerHelper.ToggleFindToolBar(_findToolBarHost, new EventHandler(OnFindInvoked), enable);
}
#region Commands
///
/// Set up Command and RoutedCommand bindings.
///
private static void CreateCommandBindings()
{
ExecutedRoutedEventHandler executedHandler;
CanExecuteRoutedEventHandler canExecuteHandler;
// Create our generic ExecutedRoutedEventHandler.
executedHandler = new ExecutedRoutedEventHandler(ExecutedRoutedEventHandler);
// Create our generic CanExecuteRoutedEventHandler
canExecuteHandler = new CanExecuteRoutedEventHandler(CanExecuteRoutedEventHandler);
// Command: SwitchViewingMode
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), FlowDocumentReader.SwitchViewingModeCommand,
executedHandler, canExecuteHandler, SRID.KeySwitchViewingMode, SRID.KeySwitchViewingModeDisplayString);
// Command: ApplicationCommands.Find
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), ApplicationCommands.Find,
executedHandler, canExecuteHandler);
// Command: ApplicationCommands.Print
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), ApplicationCommands.Print,
executedHandler, canExecuteHandler);
// Command: ApplicationCommands.CancelPrint
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), ApplicationCommands.CancelPrint,
executedHandler, canExecuteHandler);
// Command: NavigationCommands.PreviousPage
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.PreviousPage,
executedHandler, canExecuteHandler);
// Command: NavigationCommands.NextPage
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.NextPage,
executedHandler, canExecuteHandler);
// Command: NavigationCommands.FirstPage
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.FirstPage,
executedHandler, canExecuteHandler);
// Command: NavigationCommands.LastPage
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.LastPage,
executedHandler, canExecuteHandler);
// Command: NavigationCommands.IncreaseZoom
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.IncreaseZoom,
executedHandler, canExecuteHandler, new KeyGesture(Key.OemPlus, ModifierKeys.Control));
// Command: NavigationCommands.DecreaseZoom
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.DecreaseZoom,
executedHandler, canExecuteHandler, new KeyGesture(Key.OemMinus, ModifierKeys.Control));
}
///
/// Central handler for CanExecute events fired by Commands directed at FlowDocumentReader.
///
/// The target of this Command, expected to be FlowDocumentReader
/// The event arguments for this event.
private static void CanExecuteRoutedEventHandler(object target, CanExecuteRoutedEventArgs args)
{
FlowDocumentReader viewer = target as FlowDocumentReader;
Invariant.Assert(viewer != null, "Target of CanExecuteRoutedEventHandler must be FlowDocumentReader.");
Invariant.Assert(args != null, "args cannot be null.");
// FlowDocumentReader is capable of execution of the majority of its commands.
// Special rules:
// a) during printing only CancelPrint is enabled.
// b) Find command is enabled only when FindToolBar is enabled.
// c) Print command is enabled when Document is attached and printing is enabled.
// d) CancelPrint command is enabled only during printing.
// e) SwitchViewingMode command is enabled if the viewing mode is enabled, or
// the command has no parameters (will switch to the next available view).
if (!viewer._printInProgress)
{
if (args.Command == FlowDocumentReader.SwitchViewingModeCommand)
{
// This command is enabled if the viewing mode is enabled, or the command
// has no parameters (will switch to the next available view).
FlowDocumentReaderViewingMode mode;
if (viewer.ConvertToViewingMode(args.Parameter, out mode))
{
args.CanExecute = viewer.CanSwitchToViewingMode(mode);
}
else
{
args.CanExecute = (args.Parameter == null);
}
}
else if (args.Command == ApplicationCommands.Find)
{
args.CanExecute = viewer.CanShowFindToolBar;
}
else if (args.Command == ApplicationCommands.Print)
{
args.CanExecute = (viewer.Document != null) && viewer.IsPrintEnabled;
}
else if (args.Command == ApplicationCommands.CancelPrint)
{
args.CanExecute = false;
}
else
{
args.CanExecute = true;
}
}
else
{
args.CanExecute = (args.Command == ApplicationCommands.CancelPrint);
}
}
///
/// Central handler for all ExecuteEvents fired by Commands directed at FlowDocumentReader.
///
/// The target of this Command, expected to be FlowDocumentReader.
/// The event arguments associated with this event.
private static void ExecutedRoutedEventHandler(object target, ExecutedRoutedEventArgs args)
{
FlowDocumentReader viewer = target as FlowDocumentReader;
Invariant.Assert(viewer != null, "Target of ExecutedRoutedEventHandler must be FlowDocumentReader.");
Invariant.Assert(args != null, "args cannot be null.");
if (args.Command == FlowDocumentReader.SwitchViewingModeCommand)
{
viewer.TrySwitchViewingMode(args.Parameter);
}
else if (args.Command == ApplicationCommands.Find)
{
viewer.OnFindCommand();
}
else if (args.Command == ApplicationCommands.Print)
{
viewer.OnPrintCommand();
}
else if (args.Command == ApplicationCommands.CancelPrint)
{
viewer.OnCancelPrintCommand();
}
else if (args.Command == NavigationCommands.IncreaseZoom)
{
viewer.OnIncreaseZoomCommand();
}
else if (args.Command == NavigationCommands.DecreaseZoom)
{
viewer.OnDecreaseZoomCommand();
}
else if (args.Command == NavigationCommands.PreviousPage)
{
viewer.OnPreviousPageCommand();
}
else if (args.Command == NavigationCommands.NextPage)
{
viewer.OnNextPageCommand();
}
else if (args.Command == NavigationCommands.FirstPage)
{
viewer.OnFirstPageCommand();
}
else if (args.Command == NavigationCommands.LastPage)
{
viewer.OnLastPageCommand();
}
else
{
Invariant.Assert(false, "Command not handled in ExecutedRoutedEventHandler.");
}
}
///
/// Changes the current viewing mode.
///
private void TrySwitchViewingMode(object parameter)
{
FlowDocumentReaderViewingMode mode;
// Convert command parameter to viewing mode value.
// If parameter is not provided, the viewing mode is the next one available.
// If parameter cannot be converted, the command is ignored.
if (!ConvertToViewingMode(parameter, out mode))
{
if (parameter == null)
{
mode = (FlowDocumentReaderViewingMode)((((int)ViewingMode) + 1) % 3);
}
else
{
return;
}
}
// If the current ViewingMode is disabled, go to next one.
while (!CanSwitchToViewingMode(mode))
{
mode = (FlowDocumentReaderViewingMode)((((int)mode) + 1) % 3);
}
// Set new ViewingMode value.
SetCurrentValueInternal(ViewingModeProperty, mode);
}
///
/// Handler for the PreviousPage command.
///
private void OnPreviousPageCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.PreviousPage();
}
}
///
/// Handler for the NextPage command.
///
private void OnNextPageCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.NextPage();
}
}
///
/// Handler for the FirstPage command.
///
private void OnFirstPageCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.FirstPage();
}
}
///
/// Handler for the LastPage command.
///
private void OnLastPageCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.LastPage();
}
}
///
/// Invoked when the "Find" button in the Find Toolbar is clicked.
/// This method invokes the actual Find process.
///
/// The object that sent this event
/// The Click Events associated with this event
private void OnFindInvoked(object sender, EventArgs e)
{
ITextRange findResult;
TextEditor textEditor = TextEditor;
FindToolBar findToolBar = FindToolBar;
if (findToolBar != null && textEditor != null)
{
// In order to show current text selection TextEditor requires Focus to be set on the UIScope.
// If there embedded controls, it may happen that embedded control currently has focus and find
// was invoked through hotkeys. To support this case we manually move focus to the appropriate element.
if (CurrentViewer != null && CurrentViewer is UIElement)
{
((UIElement)CurrentViewer).Focus();
}
findResult = DocumentViewerHelper.Find(findToolBar, textEditor, textEditor.TextView, textEditor.TextView);
// If we found something, bring it into the view. Otherwise alert the user.
if ((findResult != null) && (!findResult.IsEmpty))
{
// Bring find result into view.
if (CurrentViewer != null)
{
CurrentViewer.ShowFindResult(findResult);
}
}
else
{
DocumentViewerHelper.ShowFindUnsuccessfulMessage(findToolBar);
}
}
}
///
/// Disable commands on IFlowDocumentViewer when this funcionality is explicitly
/// disabled on the reader control.
///
private void PreviewCanExecuteRoutedEventHandler(object target, CanExecuteRoutedEventArgs args)
{
if (args.Command == ApplicationCommands.Find)
{
// Find is handled by FlowDocumentReader.
args.CanExecute = false;
args.Handled = true;
}
else if (args.Command == ApplicationCommands.Print)
{
args.CanExecute = IsPrintEnabled;
args.Handled = !IsPrintEnabled;
}
}
///
/// Called when a key event occurs.
///
private static void KeyDownHandler(object sender, KeyEventArgs e)
{
DocumentViewerHelper.KeyDownHelper(e, ((FlowDocumentReader)sender)._findToolBarHost);
}
#endregion Commands
#region Static Methods
///
/// ViewingMode has been changed.
///
private static void ViewingModeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
if (viewer.CanSwitchToViewingMode((FlowDocumentReaderViewingMode)e.NewValue))
{
viewer.SwitchViewingModeCore((FlowDocumentReaderViewingMode)e.NewValue);
}
else if (viewer.IsInitialized)
{
throw new ArgumentException(SR.Get(SRID.FlowDocumentReaderViewingModeEnabledConflict));
}
// Fire automation events if automation is active.
FlowDocumentReaderAutomationPeer peer = UIElementAutomationPeer.FromElement(viewer) as FlowDocumentReaderAutomationPeer;
if (peer != null)
{
peer.RaiseCurrentViewChangedEvent((FlowDocumentReaderViewingMode)e.NewValue, (FlowDocumentReaderViewingMode)e.OldValue);
}
}
///
/// Validate value of ViewingMode property.
///
private static bool IsValidViewingMode(object o)
{
FlowDocumentReaderViewingMode value = (FlowDocumentReaderViewingMode)o;
return (value == FlowDocumentReaderViewingMode.Page ||
value == FlowDocumentReaderViewingMode.TwoPage ||
value == FlowDocumentReaderViewingMode.Scroll);
}
///
/// One of viewing modes has been enabled/disabled.
///
private static void ViewingModeEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
// Cannot disable all viewing modes.
if (!viewer.IsPageViewEnabled &&
!viewer.IsTwoPageViewEnabled &&
!viewer.IsScrollViewEnabled)
{
throw new ArgumentException(SR.Get(SRID.FlowDocumentReaderCannotDisableAllViewingModes));
}
// Cannot disable the current viewing mode.
if (viewer.IsInitialized && !viewer.CanSwitchToViewingMode(viewer.ViewingMode))
{
throw new ArgumentException(SR.Get(SRID.FlowDocumentReaderViewingModeEnabledConflict));
}
// Fire automation events if automation is active.
FlowDocumentReaderAutomationPeer peer = UIElementAutomationPeer.FromElement(viewer) as FlowDocumentReaderAutomationPeer;
if (peer != null)
{
peer.RaiseSupportedViewsChangedEvent(e);
}
}
///
/// IsFindEnabled value has changed.
///
private static void IsFindEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
// Update the toolbar with our current state.
if (!viewer.CanShowFindToolBar)
{
if (viewer.FindToolBar != null)
{
viewer.ToggleFindToolBar(false);
}
}
// Since IsFindEnabled state is used to determine CanExecute state, we must invalidate that state.
CommandManager.InvalidateRequerySuggested();
}
///
/// IsPrintEnabled value has changed.
///
private static void IsPrintEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
// Since IsPrintEnabled state is used to determine CanExecute state, we must invalidate that state.
CommandManager.InvalidateRequerySuggested();
}
///
/// The Document has changed and needs to be updated.
///
private static void DocumentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
viewer.DocumentChanged((FlowDocument)e.OldValue, (FlowDocument)e.NewValue);
// Since Document state is used to determine CanExecute state, we must invalidate that state.
CommandManager.InvalidateRequerySuggested();
}
///
/// The Zoom has changed and needs to be updated.
///
private static void ZoomChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
if (!DoubleUtil.AreClose((double)e.OldValue, (double)e.NewValue))
{
// If zoom has been changed, CanIncrease/DecreaseZoom property need to be updated.
viewer.SetValue(CanIncreaseZoomPropertyKey, BooleanBoxes.Box(DoubleUtil.GreaterThan(viewer.MaxZoom, viewer.Zoom)));
viewer.SetValue(CanDecreaseZoomPropertyKey, BooleanBoxes.Box(DoubleUtil.LessThan(viewer.MinZoom, viewer.Zoom)));
}
}
///
/// Coerce Zoom with Max/MinZoom, MinZoom works as the baseline.
///
private static object CoerceZoom(DependencyObject d, object value)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
double zoom = (double)value;
double maxZoom = viewer.MaxZoom;
if (DoubleUtil.LessThan(maxZoom, zoom))
{
return maxZoom;
}
double minZoom = viewer.MinZoom;
if (DoubleUtil.GreaterThan(minZoom, zoom))
{
return minZoom;
}
return value;
}
///
/// The MaxZoom has changed and needs to be updated.
///
private static void MaxZoomChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
viewer.CoerceValue(ZoomProperty);
viewer.SetValue(CanIncreaseZoomPropertyKey, BooleanBoxes.Box(DoubleUtil.GreaterThan(viewer.MaxZoom, viewer.Zoom)));
}
///
/// MaxZoom need to be coerced if MinZoom > MaxZoom
///
private static object CoerceMaxZoom(DependencyObject d, object value)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
double min = viewer.MinZoom;
return ((double)value < min) ? min : value;
}
///
/// The MinZoom has changed and needs to be updated.
///
private static void MinZoomChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
viewer.CoerceValue(MaxZoomProperty);
viewer.CoerceValue(ZoomProperty);
viewer.SetValue(CanDecreaseZoomPropertyKey, BooleanBoxes.Box(DoubleUtil.LessThan(viewer.MinZoom, viewer.Zoom)));
}
///
/// Validate Zoom, MaxZoom, MinZoom and ZoomIncrement value.
///
/// Value to validate.
/// True if the value is valid, false otherwise.
private static bool ZoomValidateValue(object o)
{
double value = (double)o;
return (!Double.IsNaN(value) && !Double.IsInfinity(value) && DoubleUtil.GreaterThan(value, 0d));
}
///
/// PropertyChanged callback for a property that affects the selection or caret rendering.
///
private static void UpdateCaretElement(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
FlowDocumentReader reader = (FlowDocumentReader)d;
if (reader.Selection != null)
{
CaretElement caretElement = reader.Selection.CaretElement;
if (caretElement != null)
{
caretElement.InvalidateVisual();
}
}
}
#endregion Static Methods
#endregion Private Methods
//--------------------------------------------------------------------
//
// Private Properties
//
//-------------------------------------------------------------------
#region Private Properties
///
/// Whether FindToolBar can be enabled.
///
private bool CanShowFindToolBar
{
get { return ((_findToolBarHost != null) && IsFindEnabled && (Document != null)); }
}
///
/// Returns TextEditor, if availabe.
///
private TextEditor TextEditor
{
get
{
TextEditor textEditor = null;
IFlowDocumentViewer currentViewer = CurrentViewer;
if (currentViewer != null && currentViewer.TextSelection != null)
{
textEditor = currentViewer.TextSelection.TextEditor;
}
return textEditor;
}
}
///
/// Returns FindToolBar, if enabled.
///
private FindToolBar FindToolBar
{
get { return (_findToolBarHost != null) ? _findToolBarHost.Child as FindToolBar : null; }
}
///
/// Returns the current content viewer.
///
private IFlowDocumentViewer CurrentViewer
{
get
{
if (_contentHost != null)
{
return (IFlowDocumentViewer)_contentHost.Child;
}
return null;
}
}
#endregion Private Properties
//-------------------------------------------------------------------
//
// Private Fields
//
//-------------------------------------------------------------------
#region Private Fields
private Decorator _contentHost; // Host for content viewer
private Decorator _findToolBarHost; // Host for FindToolBar
private ToggleButton _findButton; // Find toggle button
private ReaderPageViewer _pageViewer; // Viewer for Page viewing mode
private ReaderTwoPageViewer _twoPageViewer; // Viewer for TwoPage viewing mode
private ReaderScrollViewer _scrollViewer; // Viewer for Scroll viewing mode
private bool _documentAsLogicalChild; // Is Document part of logical tree
private bool _printInProgress; // Whether print is currently in progress.
private const string _contentHostTemplateName = "PART_ContentHost"; // Name for ContentHost
private const string _findToolBarHostTemplateName = "PART_FindToolBarHost"; // Name for the Find ToolBar host
private const string _findButtonTemplateName = "FindButton"; // Name for the Find Button
#endregion Private Fields
//--------------------------------------------------------------------
//
// IAddChild Members
//
//-------------------------------------------------------------------
#region IAddChild Members
///
/// Called to add the object as a Child.
///
/// Object to add as a child.
/// FlowDocumentScrollViewer only supports a single child of type IDocumentPaginator.
void IAddChild.AddChild(Object value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
// Check if Content has already been set.
if (this.Document != null)
{
throw new ArgumentException(SR.Get(SRID.FlowDocumentReaderCanHaveOnlyOneChild));
}
if (!(value is FlowDocument))
{
throw new ArgumentException(SR.Get(SRID.UnexpectedParameterType, value.GetType(), typeof(FlowDocument)), "value");
}
Document = value as FlowDocument;
}
///
/// Called when text appears under the tag in markup
///
/// Text to add to the Object.
/// FlowDocumentScrollViewer does not support Text children.
void IAddChild.AddText(string text)
{
XamlSerializerUtil.ThrowIfNonWhiteSpaceInAddText(text, this);
}
#endregion IAddChild Members
//--------------------------------------------------------------------
//
// IJournalState Members
//
//--------------------------------------------------------------------
#region IJournalState Members
[Serializable]
private class JournalState : CustomJournalStateInternal
{
public JournalState(int contentPosition, LogicalDirection contentPositionDirection, double zoom, FlowDocumentReaderViewingMode viewingMode)
{
ContentPosition = contentPosition;
ContentPositionDirection = contentPositionDirection;
Zoom = zoom;
ViewingMode = viewingMode;
}
public int ContentPosition;
public LogicalDirection ContentPositionDirection;
public double Zoom;
public FlowDocumentReaderViewingMode ViewingMode;
}
///
///
CustomJournalStateInternal IJournalState.GetJournalState(JournalReason journalReason)
{
int cp = -1;
LogicalDirection cpDirection = LogicalDirection.Forward;
IFlowDocumentViewer viewer = CurrentViewer;
if (viewer != null)
{
TextPointer contentPosition = viewer.ContentPosition as TextPointer;
if (contentPosition != null)
{
cp = contentPosition.Offset;
cpDirection = contentPosition.LogicalDirection;
}
}
return new JournalState(cp, cpDirection, Zoom, ViewingMode);
}
///
///
void IJournalState.RestoreJournalState(CustomJournalStateInternal state)
{
JournalState viewerState = state as JournalState;
if (state != null)
{
SetCurrentValueInternal(ZoomProperty, viewerState.Zoom);
SetCurrentValueInternal(ViewingModeProperty, viewerState.ViewingMode);
if (viewerState.ContentPosition != -1)
{
IFlowDocumentViewer viewer = CurrentViewer;
FlowDocument document = Document;
if (viewer != null && document != null)
{
TextContainer textContainer = document.StructuralCache.TextContainer;
if (viewerState.ContentPosition <= textContainer.SymbolCount)
{
TextPointer contentPosition = textContainer.CreatePointerAtOffset(viewerState.ContentPosition, viewerState.ContentPositionDirection);
viewer.ContentPosition = contentPosition;
}
}
}
}
}
#endregion IJournalState Members
//-------------------------------------------------------------------
//
// DTypeThemeStyleKey
//
//--------------------------------------------------------------------
#region DTypeThemeStyleKey
///
/// Returns the DependencyObjectType for the registered ThemeStyleKey's default
/// value. Controls will override this method to return approriate types
///
internal override DependencyObjectType DTypeThemeStyleKey
{
get { return _dType; }
}
private static DependencyObjectType _dType;
#endregion DTypeThemeStyleKey
//-------------------------------------------------------------------
//
// Style Keys
//
//-------------------------------------------------------------------
#region Style Keys
///
/// Key used to mark the style for use by the PageView
///
private static ResourceKey PageViewStyleKey
{
get
{
if (_pageViewStyleKey == null)
{
_pageViewStyleKey = new ComponentResourceKey(typeof(PresentationUIStyleResources), "PUIPageViewStyleKey");
}
return _pageViewStyleKey;
}
}
///
/// Key used to mark the style for use by the TwoPageView
///
private static ResourceKey TwoPageViewStyleKey
{
get
{
if (_twoPageViewStyleKey == null)
{
_twoPageViewStyleKey = new ComponentResourceKey(typeof(PresentationUIStyleResources), "PUITwoPageViewStyleKey");
}
return _twoPageViewStyleKey;
}
}
///
/// Key used to mark the style for use by the ScrollView
///
private static ResourceKey ScrollViewStyleKey
{
get
{
if (_scrollViewStyleKey == null)
{
_scrollViewStyleKey = new ComponentResourceKey(typeof(PresentationUIStyleResources), "PUIScrollViewStyleKey");
}
return _scrollViewStyleKey;
}
}
private static ComponentResourceKey _pageViewStyleKey;
private static ComponentResourceKey _twoPageViewStyleKey;
private static ComponentResourceKey _scrollViewStyleKey;
#endregion
}
///
///
public enum FlowDocumentReaderViewingMode
{
///
///
Page,
///
///
TwoPage,
///
///
Scroll
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//---------------------------------------------------------------------------
using System; // Object
using System.Collections; // IEnumerator
using System.Collections.ObjectModel; // ReadOnlyCollection
using System.Security; // SecurityCritical
using System.Windows.Automation.Peers; // AutomationPeer
using System.Windows.Data; // BindingOperations
using System.Windows.Controls.Primitives; // PlacementMode
using System.Windows.Documents; // FlowDocument
using System.Windows.Input; // KeyEventArgs
using System.Windows.Media; // ScaleTransform, VisualTreeHelper
using System.Windows.Markup; // IAddChild
using System.Windows.Threading; // Dispatcher
using MS.Internal; // Invariant, DoubleUtil
using MS.Internal.Commands; // CommandHelpers
using MS.Internal.Controls; // EmptyEnumerator
using MS.Internal.Documents; // FindToolBar
using MS.Internal.KnownBoxes; // BooleanBoxes
using MS.Internal.AppModel; // IJournalState
namespace System.Windows.Controls
{
///
/// FlowDocumentReader provides a full user experience for consuming text content.
/// It will be used as the default viewer for loose XAML or containers that contain
/// text content, and can be styled and re-used by developers for use within their applications.
///
[TemplatePart(Name = "PART_ContentHost", Type = typeof(Decorator))]
[TemplatePart(Name = "PART_FindToolBarHost", Type = typeof(Decorator))]
[ContentProperty("Document")]
public class FlowDocumentReader : Control, IAddChild, IJournalState
{
//-------------------------------------------------------------------
//
// Constructors
//
//-------------------------------------------------------------------
#region Constructors
///
/// Static Constructor
///
static FlowDocumentReader()
{
DefaultStyleKeyProperty.OverrideMetadata(
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(new ComponentResourceKey(typeof(PresentationUIStyleResources), "PUIFlowDocumentReader")));
_dType = DependencyObjectType.FromSystemTypeInternal(typeof(FlowDocumentReader));
TextBoxBase.SelectionBrushProperty.OverrideMetadata(typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(new PropertyChangedCallback(UpdateCaretElement)));
TextBoxBase.SelectionOpacityProperty.OverrideMetadata(typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(new PropertyChangedCallback(UpdateCaretElement)));
CreateCommandBindings();
EventManager.RegisterClassHandler(typeof(FlowDocumentReader), Keyboard.KeyDownEvent, new KeyEventHandler(KeyDownHandler), true);
}
///
/// Default Constructor
///
public FlowDocumentReader()
: base()
{
}
#endregion Constructors
//--------------------------------------------------------------------
//
// Public Methods
//
//-------------------------------------------------------------------
#region Public Methods
///
/// Build Visual tree
///
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
// Initialize ContentHost.
// If old ContentHost is enabled, disable it first to ensure appropriate cleanup.
if (CurrentViewer != null)
{
DetachViewer(CurrentViewer);
_contentHost.Child = null;
}
_contentHost = GetTemplateChild(_contentHostTemplateName) as Decorator;
if (_contentHost != null)
{
if (_contentHost.Child != null)
{
throw new NotSupportedException(SR.Get(SRID.FlowDocumentReaderDecoratorMarkedAsContentHostMustHaveNoContent));
}
SwitchViewingModeCore(ViewingMode);
}
// Initialize FindTooBar host.
// If old FindToolBar is enabled, disable it first to ensure appropriate cleanup.
if (FindToolBar != null)
{
ToggleFindToolBar(false);
}
_findToolBarHost = GetTemplateChild(_findToolBarHostTemplateName) as Decorator;
_findButton = GetTemplateChild(_findButtonTemplateName) as ToggleButton;
}
///
/// Whether the master page can be moved to the specified page.
///
/// Page number.
public bool CanGoToPage(int pageNumber)
{
bool canGoToPage = false;
if (CurrentViewer != null)
{
canGoToPage = CurrentViewer.CanGoToPage(pageNumber);
}
return canGoToPage;
}
///
/// Invokes the Find Toolbar. This is analogous to the ApplicationCommands.Find.
///
public void Find()
{
OnFindCommand();
}
///
/// Invokes the Print Dialog. This is analogous to the ApplicationCommands.Print.
///
public void Print()
{
OnPrintCommand();
}
///
/// Cancels current printing job. This is analogous to the ApplicationCommands.CancelPrint.
///
public void CancelPrint()
{
OnCancelPrintCommand();
}
///
/// Increases the current zoom.
///
public void IncreaseZoom()
{
OnIncreaseZoomCommand();
}
///
/// Decreases the current zoom.
///
public void DecreaseZoom()
{
OnDecreaseZoomCommand();
}
///
/// Switches the current viewing mode. This is analogous to the SwitchViewingModeCommand.
///
/// Viewing mode.
public void SwitchViewingMode(FlowDocumentReaderViewingMode viewingMode)
{
OnSwitchViewingModeCommand(viewingMode);
}
#endregion Public Methods
//--------------------------------------------------------------------
//
// Public Properties
//
//--------------------------------------------------------------------
#region Public Properties
///
/// ViewingMode of FlowDocumentReader.
///
public FlowDocumentReaderViewingMode ViewingMode
{
get { return (FlowDocumentReaderViewingMode)GetValue(ViewingModeProperty); }
set { SetValue(ViewingModeProperty, value); }
}
///
/// Text Selection (readonly)
///
public TextSelection Selection
{
get
{
TextSelection result = null;
IFlowDocumentViewer viewer;
if (_contentHost != null)
{
viewer = _contentHost.Child as IFlowDocumentViewer;
if(viewer != null)
{
result = viewer.TextSelection as TextSelection;
}
}
return result;
}
}
///
/// Whether Page view can be enabled or not.
///
public bool IsPageViewEnabled
{
get { return (bool)GetValue(IsPageViewEnabledProperty); }
set { SetValue(IsPageViewEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// Whether TwoPage view can be enabled or not.
///
public bool IsTwoPageViewEnabled
{
get { return (bool)GetValue(IsTwoPageViewEnabledProperty); }
set { SetValue(IsTwoPageViewEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// Whether Scroll view can be enabled or not.
///
public bool IsScrollViewEnabled
{
get { return (bool)GetValue(IsScrollViewEnabledProperty); }
set { SetValue(IsScrollViewEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// The number of pages currently available for viewing. This value
/// is updated as content is paginated, and will change dramatically
/// when the content is resized, or edited.
///
public int PageCount
{
get { return (int)GetValue(PageCountProperty); }
}
///
/// The one-based page number of the page being displayed. If there is no content,
/// this value will be 0.
///
public int PageNumber
{
get { return (int)GetValue(PageNumberProperty); }
}
///
/// Whether the viewer can move the master page to the previous page.
///
public bool CanGoToPreviousPage
{
get { return (bool)GetValue(CanGoToPreviousPageProperty); }
}
///
/// Whether the viewer can advance the master page to the next page.
///
public bool CanGoToNextPage
{
get { return (bool)GetValue(CanGoToNextPageProperty); }
}
///
/// Is find function enabled or not
///
public bool IsFindEnabled
{
get { return (bool)GetValue(IsFindEnabledProperty); }
set { SetValue(IsFindEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// Is print function enabled or not
///
public bool IsPrintEnabled
{
get { return (bool)GetValue(IsPrintEnabledProperty); }
set { SetValue(IsPrintEnabledProperty, BooleanBoxes.Box(value)); }
}
///
/// A Property representing a content of this FlowDocumentScrollViewer.
///
public FlowDocument Document
{
get { return (FlowDocument)GetValue(DocumentProperty); }
set { SetValue(DocumentProperty, value); }
}
///
/// The Zoom applied to all pages; this value is 100-based.
///
public double Zoom
{
get { return (double)GetValue(ZoomProperty); }
set { SetValue(ZoomProperty, value); }
}
///
/// The maximum allowed value of the Zoom property.
///
public double MaxZoom
{
get { return (double)GetValue(MaxZoomProperty); }
set { SetValue(MaxZoomProperty, value); }
}
///
/// The minimum allowed value of the Zoom property.
///
public double MinZoom
{
get { return (double)GetValue(MinZoomProperty); }
set { SetValue(MinZoomProperty, value); }
}
///
/// The amount the Zoom property is incremented or decremented when
/// the IncreaseZoom or DecreaseZoom command is executed.
///
public double ZoomIncrement
{
get { return (double)GetValue(ZoomIncrementProperty); }
set { SetValue(ZoomIncrementProperty, value); }
}
///
/// Whether the viewer can increase the current zoom.
///
public bool CanIncreaseZoom
{
get { return (bool)GetValue(CanIncreaseZoomProperty); }
}
///
/// Whether the viewer can decrease the current zoom.
///
public bool CanDecreaseZoom
{
get { return (bool)GetValue(CanDecreaseZoomProperty); }
}
///
///
public Brush SelectionBrush
{
get { return (Brush)GetValue(SelectionBrushProperty); }
set { SetValue(SelectionBrushProperty, value); }
}
///
///
public double SelectionOpacity
{
get { return (double)GetValue(SelectionOpacityProperty); }
set { SetValue(SelectionOpacityProperty, value); }
}
#region Public Dynamic Properties
///
///
public static readonly DependencyProperty ViewingModeProperty =
DependencyProperty.Register(
"ViewingMode",
typeof(FlowDocumentReaderViewingMode),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
FlowDocumentReaderViewingMode.Page,
FrameworkPropertyMetadataOptions.AffectsMeasure,
new PropertyChangedCallback(ViewingModeChanged)),
new ValidateValueCallback(IsValidViewingMode));
///
///
public static readonly DependencyProperty IsPageViewEnabledProperty =
DependencyProperty.Register(
"IsPageViewEnabled",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
BooleanBoxes.TrueBox,
new PropertyChangedCallback(ViewingModeEnabledChanged)));
///
///
public static readonly DependencyProperty IsTwoPageViewEnabledProperty =
DependencyProperty.Register(
"IsTwoPageViewEnabled",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
BooleanBoxes.TrueBox,
new PropertyChangedCallback(ViewingModeEnabledChanged)));
///
///
public static readonly DependencyProperty IsScrollViewEnabledProperty =
DependencyProperty.Register(
"IsScrollViewEnabled",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
BooleanBoxes.TrueBox,
new PropertyChangedCallback(ViewingModeEnabledChanged)));
///
///
private static readonly DependencyPropertyKey PageCountPropertyKey =
DependencyProperty.RegisterReadOnly(
"PageCount",
typeof(int),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(0));
///
///
public static readonly DependencyProperty PageCountProperty = PageCountPropertyKey.DependencyProperty;
///
///
private static readonly DependencyPropertyKey PageNumberPropertyKey =
DependencyProperty.RegisterReadOnly(
"PageNumber",
typeof(int),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(0));
///
///
public static readonly DependencyProperty PageNumberProperty = PageNumberPropertyKey.DependencyProperty;
///
///
private static readonly DependencyPropertyKey CanGoToPreviousPagePropertyKey =
DependencyProperty.RegisterReadOnly(
"CanGoToPreviousPage",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(BooleanBoxes.FalseBox));
///
///
public static readonly DependencyProperty CanGoToPreviousPageProperty = CanGoToPreviousPagePropertyKey.DependencyProperty;
///
///
private static readonly DependencyPropertyKey CanGoToNextPagePropertyKey =
DependencyProperty.RegisterReadOnly(
"CanGoToNextPage",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(BooleanBoxes.FalseBox));
///
///
public static readonly DependencyProperty CanGoToNextPageProperty = CanGoToNextPagePropertyKey.DependencyProperty;
///
///
public static readonly DependencyProperty IsFindEnabledProperty =
DependencyProperty.Register(
"IsFindEnabled",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
BooleanBoxes.TrueBox,
new PropertyChangedCallback(IsFindEnabledChanged)));
///
///
public static readonly DependencyProperty IsPrintEnabledProperty =
DependencyProperty.Register(
"IsPrintEnabled",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
BooleanBoxes.TrueBox,
new PropertyChangedCallback(IsPrintEnabledChanged)));
///
///
public static readonly DependencyProperty DocumentProperty =
DependencyProperty.Register(
"Document",
typeof(FlowDocument),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
null,
new PropertyChangedCallback(DocumentChanged)));
///
///
public static readonly DependencyProperty ZoomProperty =
FlowDocumentPageViewer.ZoomProperty.AddOwner(
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
100d,
new PropertyChangedCallback(ZoomChanged),
new CoerceValueCallback(CoerceZoom)));
///
///
public static readonly DependencyProperty MaxZoomProperty =
FlowDocumentPageViewer.MaxZoomProperty.AddOwner(
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
200d,
new PropertyChangedCallback(MaxZoomChanged),
new CoerceValueCallback(CoerceMaxZoom)));
///
///
public static readonly DependencyProperty MinZoomProperty =
FlowDocumentPageViewer.MinZoomProperty.AddOwner(
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(
80d,
new PropertyChangedCallback(MinZoomChanged)));
///
///
public static readonly DependencyProperty ZoomIncrementProperty =
FlowDocumentPageViewer.ZoomIncrementProperty.AddOwner(
typeof(FlowDocumentReader));
///
///
private static readonly DependencyPropertyKey CanIncreaseZoomPropertyKey =
DependencyProperty.RegisterReadOnly(
"CanIncreaseZoom",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(BooleanBoxes.TrueBox));
///
///
public static readonly DependencyProperty CanIncreaseZoomProperty = CanIncreaseZoomPropertyKey.DependencyProperty;
///
///
private static readonly DependencyPropertyKey CanDecreaseZoomPropertyKey =
DependencyProperty.RegisterReadOnly(
"CanDecreaseZoom",
typeof(bool),
typeof(FlowDocumentReader),
new FrameworkPropertyMetadata(BooleanBoxes.TrueBox));
///
///
public static readonly DependencyProperty CanDecreaseZoomProperty = CanDecreaseZoomPropertyKey.DependencyProperty;
///
///
public static readonly DependencyProperty SelectionBrushProperty =
TextBoxBase.SelectionBrushProperty.AddOwner(typeof(FlowDocumentReader));
///
///
public static readonly DependencyProperty SelectionOpacityProperty =
TextBoxBase.SelectionOpacityProperty.AddOwner(typeof(FlowDocumentReader));
#endregion Public Dynamic Properties
#endregion Public Properties
//-------------------------------------------------------------------
//
// Public Commands
//
//--------------------------------------------------------------------
#region Public Commands
///
/// Switch ViewingMode command
///
public static readonly RoutedUICommand SwitchViewingModeCommand = new RoutedUICommand(SR.Get(SRID.SwitchViewingMode), "SwitchViewingMode", typeof(FlowDocumentReader), null);
#endregion
//-------------------------------------------------------------------
//
// Protected Methods
//
//-------------------------------------------------------------------
#region Protected Methods
///
/// Called when print has been completed.
///
protected virtual void OnPrintCompleted()
{
if (_printInProgress)
{
_printInProgress = false;
// Since _printInProgress value is used to determine CanExecute state, we must invalidate that state.
CommandManager.InvalidateRequerySuggested();
}
}
///
/// Handler for the Find command
///
protected virtual void OnFindCommand()
{
if (CanShowFindToolBar)
{
// Toggle on the FindToolBar between visible and hidden state.
ToggleFindToolBar(FindToolBar == null);
}
}
///
/// Handler for the Print command.
///
protected virtual void OnPrintCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.Print();
}
}
///
/// Handler for the CancelPrint command.
///
protected virtual void OnCancelPrintCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.CancelPrint();
}
}
///
/// Handler for the IncreaseZoom command.
///
protected virtual void OnIncreaseZoomCommand()
{
// If can zoom in, increase zoom by the zoom increment value.
if (CanIncreaseZoom)
{
SetCurrentValueInternal(ZoomProperty, Math.Min(Zoom + ZoomIncrement, MaxZoom));
}
}
///
/// Handler for the DecreaseZoom command.
///
protected virtual void OnDecreaseZoomCommand()
{
// If can zoom out, decrease zoom by the zoom increment value.
if (CanDecreaseZoom)
{
SetCurrentValueInternal(ZoomProperty, Math.Max(Zoom - ZoomIncrement, MinZoom));
}
}
///
/// Handler for the SwitchViewingMode command.
///
/// Viewing mode.
protected virtual void OnSwitchViewingModeCommand(FlowDocumentReaderViewingMode viewingMode)
{
SwitchViewingModeCore(viewingMode);
}
///
/// Called when IsInitialized is set to true.
///
/// Event arguments
protected override void OnInitialized(EventArgs e)
{
base.OnInitialized(e);
// Defer the Is*ViewEnabled & ViewingMode conflict exception.
// Otherwise
/// Creates AutomationPeer (
protected override AutomationPeer OnCreateAutomationPeer()
{
return new FlowDocumentReaderAutomationPeer(this);
}
///
/// An event reporting that the IsKeyboardFocusWithin property changed.
///
protected override void OnIsKeyboardFocusWithinChanged(DependencyPropertyChangedEventArgs e)
{
base.OnIsKeyboardFocusWithinChanged(e);
// In order to enable selection rendering and other similar services, the embedded viewer
// needs to get focus, when any part of the control gets focused.
// But if the focus is within the Document, do not change it. Otherwise it
// will interfere with input handling inside the Document.
if (IsKeyboardFocusWithin && CurrentViewer != null)
{
bool isFocusWithinDocument = IsFocusWithinDocument();
if (!isFocusWithinDocument)
{
((FrameworkElement)CurrentViewer).Focus();
}
}
}
///
/// This is the method that responds to the KeyDown event.
///
/// Event arguments
///
/// Critical: get_SearchUp is defined in a non-APTCA assembly.
/// TreatAsSafe: call to get_SearchUp does not entail any risk.
///
[SecurityCritical, SecurityTreatAsSafe]
protected override void OnKeyDown(KeyEventArgs e)
{
if (e.Handled) { return; }
switch (e.Key)
{
// Esc -- Close FindToolBar
case Key.Escape:
if (FindToolBar != null)
{
ToggleFindToolBar(false);
e.Handled = true;
}
break;
// F3 -- Invoke Find
case Key.F3:
if (CanShowFindToolBar)
{
if (FindToolBar != null)
{
// If the Shift key is also pressed, then search up.
FindToolBar.SearchUp = ((e.KeyboardDevice.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift);
OnFindInvoked(this, EventArgs.Empty);
}
else
{
// Make the FindToolBar visible
ToggleFindToolBar(true);
}
e.Handled = true;
}
break;
}
// If not handled, do default handling.
if (!e.Handled)
{
base.OnKeyDown(e);
}
}
#endregion Protected Methods
//-------------------------------------------------------------------
//
// Protected Properties
//
//--------------------------------------------------------------------
#region Protected Properties
///
/// Returns enumerator to logical children.
///
protected internal override IEnumerator LogicalChildren
{
get
{
if (HasLogicalChildren && Document != null)
{
return new SingleChildEnumerator(Document);
}
return EmptyEnumerator.Instance;
}
}
#endregion Protected Properties
//-------------------------------------------------------------------
//
// Internal Methods
//
//--------------------------------------------------------------------
#region Internal Methods
///
/// Allows FrameworkElement to augment the EventRoute.
///
internal override bool BuildRouteCore(EventRoute route, RoutedEventArgs args)
{
// Do not add intermediate ContentElements to the route,
// because they were added by embedded viewer.
return BuildRouteCoreHelper(route, args, false);
}
#endregion Internal Methods
//--------------------------------------------------------------------
//
// Private Methods
//
//-------------------------------------------------------------------
#region Private Methods
///
/// Handler for the SwitchViewingMode command.
///
/// Viewing mode.
protected virtual void SwitchViewingModeCore(FlowDocumentReaderViewingMode viewingMode)
{
ITextSelection textSelection = null;
ContentPosition contentPosition = null;
IFlowDocumentViewer viewer;
FrameworkElement feViewer;
bool isKeyboardFocusWithin;
DependencyObject focusedElement = null;
if (_contentHost != null)
{
// Remember the current keyboard focus state.
isKeyboardFocusWithin = IsKeyboardFocusWithin;
// Detach old viewer
viewer = _contentHost.Child as IFlowDocumentViewer;
if (viewer != null)
{
// Remember focused element, if the focus is within the Document.
// After switching to a different viewer, this focus needs to be restored.
if (isKeyboardFocusWithin)
{
bool isFocusWithinDocument = IsFocusWithinDocument();
if (isFocusWithinDocument)
{
focusedElement = Keyboard.FocusedElement as DependencyObject;
}
}
// Retrieve the current viewing state from the old viewer.
textSelection = viewer.TextSelection;
contentPosition = viewer.ContentPosition;
// Detach old viewer
DetachViewer(viewer);
}
viewer = GetViewerFromMode(viewingMode);
feViewer = (FrameworkElement)viewer;
if (viewer != null)
{
// Attach new viewer
_contentHost.Child = feViewer;
AttachViewer(viewer);
// Restore viewing state.
viewer.TextSelection = textSelection;
viewer.ContentPosition = contentPosition;
// Bring the focus to previously focused element within the document
// or to the current viewer.
if (isKeyboardFocusWithin)
{
if (focusedElement is UIElement)
{
((UIElement)focusedElement).Focus();
}
else if (focusedElement is ContentElement)
{
((ContentElement)focusedElement).Focus();
}
else
{
feViewer.Focus();
}
}
}
// Viewer changes invalidates following properties:
// - PageCount
// - PageNumber
// - CanGoToPreviousPage
// - CanGoToNextPage
UpdateReadOnlyProperties(true, true);
}
}
///
/// Determines whether focus is within Document.
///
private bool IsFocusWithinDocument()
{
DependencyObject focusedElement = Keyboard.FocusedElement as DependencyObject;
while (focusedElement != null && focusedElement != Document)
{
// Skip elements in the control's template (if such exists) and
// walk up logical tree to find if the focused element is within
// the document.
FrameworkElement fe = focusedElement as FrameworkElement;
if (fe != null && fe.TemplatedParent != null)
{
focusedElement = fe.TemplatedParent;
}
else
{
focusedElement = LogicalTreeHelper.GetParent(focusedElement);
}
}
return (focusedElement != null);
}
///
/// The Document has changed and needs to be updated.
///
private void DocumentChanged(FlowDocument oldDocument, FlowDocument newDocument)
{
// Cleanup state associated with the old document.
if (oldDocument != null)
{
// If Document was added to logical tree before, remove it.
if (_documentAsLogicalChild)
{
RemoveLogicalChild(oldDocument);
}
}
// If FlowDocumentReader was created through style, then do not modify
// the logical tree. Instead, set "core parent" for the Document.
if (TemplatedParent != null && newDocument != null && LogicalTreeHelper.GetParent(newDocument) != null)
{
// Set the "core parent" back to us.
ContentOperations.SetParent(newDocument, this);
_documentAsLogicalChild = false;
}
else
{
_documentAsLogicalChild = true;
}
// Initialize state associated with the new document.
if (newDocument != null)
{
// If Document should be part of DocumentViewer's logical tree, add it.
if (_documentAsLogicalChild)
{
AddLogicalChild(newDocument);
}
}
// Attach document to the current viewer.
if (CurrentViewer != null)
{
CurrentViewer.SetDocument(newDocument);
}
// Document invalidation invalidates following properties:
// - PageCount
// - PageNumber
// - CanGoToPreviousPage
// - CanGoToNextPage
UpdateReadOnlyProperties(true, true);
// Update the toolbar with our current document state.
if (!CanShowFindToolBar)
{
// Disable FindToolBar, if the content does not support it.
if (FindToolBar != null)
{
ToggleFindToolBar(false);
}
}
// Document is also represented as Automation child. Need to invalidate peer to force update.
FlowDocumentReaderAutomationPeer peer = UIElementAutomationPeer.FromElement(this) as FlowDocumentReaderAutomationPeer;
if (peer != null)
{
peer.InvalidatePeer();
}
}
///
/// Detach embedded viewer form the reader control.
///
private void DetachViewer(IFlowDocumentViewer viewer)
{
Invariant.Assert(viewer != null && viewer is FrameworkElement);
FrameworkElement feViewer = (FrameworkElement)viewer;
// Clear property bindings.
BindingOperations.ClearBinding(feViewer, ZoomProperty);
BindingOperations.ClearBinding(feViewer, MaxZoomProperty);
BindingOperations.ClearBinding(feViewer, MinZoomProperty);
BindingOperations.ClearBinding(feViewer, ZoomIncrementProperty);
// Unregister event handlers.
viewer.PageCountChanged -= new EventHandler(OnPageCountChanged);
viewer.PageNumberChanged -= new EventHandler(OnPageNumberChanged);
viewer.PrintStarted -= new EventHandler(OnViewerPrintStarted);
viewer.PrintCompleted -= new EventHandler(OnViewerPrintCompleted);
// Clear TemplatedParent
//feViewer._templatedParent = null;
// Detach document
viewer.SetDocument(null);
}
///
/// Attach embedded viewer to the reader control.
///
private void AttachViewer(IFlowDocumentViewer viewer)
{
Invariant.Assert(viewer != null && viewer is FrameworkElement);
FrameworkElement feViewer = (FrameworkElement)viewer;
// Set document
viewer.SetDocument(Document);
// Set TemplatedParent
//feViewer._templatedParent = TemplatedParent;
// Register event handlers.
viewer.PageCountChanged += new EventHandler(OnPageCountChanged);
viewer.PageNumberChanged += new EventHandler(OnPageNumberChanged);
viewer.PrintStarted += new EventHandler(OnViewerPrintStarted);
viewer.PrintCompleted += new EventHandler(OnViewerPrintCompleted);
// Create property bindings.
CreateTwoWayBinding(feViewer, ZoomProperty, "Zoom");
CreateTwoWayBinding(feViewer, MaxZoomProperty, "MaxZoom");
CreateTwoWayBinding(feViewer, MinZoomProperty, "MinZoom");
CreateTwoWayBinding(feViewer, ZoomIncrementProperty, "ZoomIncrement");
}
///
/// Create two way property binding.
///
private void CreateTwoWayBinding(FrameworkElement fe, DependencyProperty dp, string propertyPath)
{
Binding binding = new Binding(propertyPath);
binding.Mode = BindingMode.TwoWay;
binding.Source = this;
fe.SetBinding(dp, binding);
}
///
/// Determines whether can switch to specified ViewingMode or not.
///
private bool CanSwitchToViewingMode(FlowDocumentReaderViewingMode mode)
{
bool canSwitch = false;
switch (mode)
{
case FlowDocumentReaderViewingMode.Page:
canSwitch = IsPageViewEnabled;
break;
case FlowDocumentReaderViewingMode.TwoPage:
canSwitch = IsTwoPageViewEnabled;
break;
case FlowDocumentReaderViewingMode.Scroll:
canSwitch = IsScrollViewEnabled;
break;
}
return canSwitch;
}
///
/// Retrieves viewer form specified ViewingMode.
///
private IFlowDocumentViewer GetViewerFromMode(FlowDocumentReaderViewingMode mode)
{
IFlowDocumentViewer viewer = null;
switch (mode)
{
case FlowDocumentReaderViewingMode.Page:
if (_pageViewer == null)
{
_pageViewer = new ReaderPageViewer();
_pageViewer.SetResourceReference(StyleProperty, PageViewStyleKey);
_pageViewer.Name = "PageViewer";
CommandManager.AddPreviewCanExecuteHandler(_pageViewer, new CanExecuteRoutedEventHandler(PreviewCanExecuteRoutedEventHandler));
}
viewer = _pageViewer;
break;
case FlowDocumentReaderViewingMode.TwoPage:
if (_twoPageViewer == null)
{
_twoPageViewer = new ReaderTwoPageViewer();
_twoPageViewer.SetResourceReference(StyleProperty, TwoPageViewStyleKey);
_twoPageViewer.Name = "TwoPageViewer";
CommandManager.AddPreviewCanExecuteHandler(_twoPageViewer, new CanExecuteRoutedEventHandler(PreviewCanExecuteRoutedEventHandler));
}
viewer = _twoPageViewer;
break;
case FlowDocumentReaderViewingMode.Scroll:
if (_scrollViewer == null)
{
_scrollViewer = new ReaderScrollViewer();
_scrollViewer.SetResourceReference(StyleProperty, ScrollViewStyleKey);
_scrollViewer.Name = "ScrollViewer";
CommandManager.AddPreviewCanExecuteHandler(_scrollViewer, new CanExecuteRoutedEventHandler(PreviewCanExecuteRoutedEventHandler));
}
viewer = _scrollViewer;
break;
}
return viewer;
}
///
/// Update values for readonly properties.
///
/// Whether PageCount has been changed.
/// Whether PageNumber has been changed.
private void UpdateReadOnlyProperties(bool pageCountChanged, bool pageNumberChanged)
{
if (pageCountChanged)
{
SetValue(PageCountPropertyKey, (CurrentViewer != null) ? CurrentViewer.PageCount : 0);
}
if (pageNumberChanged)
{
SetValue(PageNumberPropertyKey, (CurrentViewer != null) ? CurrentViewer.PageNumber : 0);
SetValue(CanGoToPreviousPagePropertyKey, (CurrentViewer != null) ? CurrentViewer.CanGoToPreviousPage : false);
}
if (pageCountChanged || pageNumberChanged)
{
SetValue(CanGoToNextPagePropertyKey, (CurrentViewer != null) ? CurrentViewer.CanGoToNextPage : false);
}
}
///
/// Event handler for IFlowDocumentViewer.PageCountChanged.
///
private void OnPageCountChanged(object sender, EventArgs e)
{
Invariant.Assert(CurrentViewer != null && sender == CurrentViewer);
UpdateReadOnlyProperties(true, false);
}
///
/// Event handler for IFlowDocumentViewer.PageNumberChanged.
///
private void OnPageNumberChanged(object sender, EventArgs e)
{
Invariant.Assert(CurrentViewer != null && sender == CurrentViewer);
UpdateReadOnlyProperties(false, true);
}
///
/// Event handler for IFlowDocumentViewer.PrintStarted.
///
private void OnViewerPrintStarted(object sender, EventArgs e)
{
Invariant.Assert(CurrentViewer != null && sender == CurrentViewer);
_printInProgress = true;
// Since _printInProgress value is used to determine CanExecute state, we must invalidate that state.
CommandManager.InvalidateRequerySuggested();
}
///
/// Event handler for IFlowDocumentViewer.PrintCompleted.
///
private void OnViewerPrintCompleted(object sender, EventArgs e)
{
Invariant.Assert(CurrentViewer != null && sender == CurrentViewer);
OnPrintCompleted();
}
///
/// Convert object value to FlowDocumentReaderViewingMode.
///
private bool ConvertToViewingMode(object value, out FlowDocumentReaderViewingMode mode)
{
bool success;
if (value is FlowDocumentReaderViewingMode)
{
mode = (FlowDocumentReaderViewingMode)value;
success = true;
}
else if (value is String)
{
String str = (String)value;
if (str == FlowDocumentReaderViewingMode.Page.ToString())
{
mode = FlowDocumentReaderViewingMode.Page;
success = true;
}
else if (str == FlowDocumentReaderViewingMode.TwoPage.ToString())
{
mode = FlowDocumentReaderViewingMode.TwoPage;
success = true;
}
else if (str == FlowDocumentReaderViewingMode.Scroll.ToString())
{
mode = FlowDocumentReaderViewingMode.Scroll;
success = true;
}
else
{
mode = FlowDocumentReaderViewingMode.Page;
success = false;
}
}
else
{
mode = FlowDocumentReaderViewingMode.Page;
success = false;
}
return success;
}
///
/// Enables/disables the FindToolBar.
///
/// Whether to enable/disable FindToolBar.
private void ToggleFindToolBar(bool enable)
{
Invariant.Assert(enable == (FindToolBar == null));
// Command event for toggle button is only fired in OnClick - Therefore we just need to change the state
if(_findButton != null && _findButton.IsChecked.HasValue && _findButton.IsChecked.Value != enable)
{
_findButton.IsChecked = enable;
}
DocumentViewerHelper.ToggleFindToolBar(_findToolBarHost, new EventHandler(OnFindInvoked), enable);
}
#region Commands
///
/// Set up Command and RoutedCommand bindings.
///
private static void CreateCommandBindings()
{
ExecutedRoutedEventHandler executedHandler;
CanExecuteRoutedEventHandler canExecuteHandler;
// Create our generic ExecutedRoutedEventHandler.
executedHandler = new ExecutedRoutedEventHandler(ExecutedRoutedEventHandler);
// Create our generic CanExecuteRoutedEventHandler
canExecuteHandler = new CanExecuteRoutedEventHandler(CanExecuteRoutedEventHandler);
// Command: SwitchViewingMode
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), FlowDocumentReader.SwitchViewingModeCommand,
executedHandler, canExecuteHandler, SRID.KeySwitchViewingMode, SRID.KeySwitchViewingModeDisplayString);
// Command: ApplicationCommands.Find
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), ApplicationCommands.Find,
executedHandler, canExecuteHandler);
// Command: ApplicationCommands.Print
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), ApplicationCommands.Print,
executedHandler, canExecuteHandler);
// Command: ApplicationCommands.CancelPrint
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), ApplicationCommands.CancelPrint,
executedHandler, canExecuteHandler);
// Command: NavigationCommands.PreviousPage
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.PreviousPage,
executedHandler, canExecuteHandler);
// Command: NavigationCommands.NextPage
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.NextPage,
executedHandler, canExecuteHandler);
// Command: NavigationCommands.FirstPage
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.FirstPage,
executedHandler, canExecuteHandler);
// Command: NavigationCommands.LastPage
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.LastPage,
executedHandler, canExecuteHandler);
// Command: NavigationCommands.IncreaseZoom
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.IncreaseZoom,
executedHandler, canExecuteHandler, new KeyGesture(Key.OemPlus, ModifierKeys.Control));
// Command: NavigationCommands.DecreaseZoom
CommandHelpers.RegisterCommandHandler(typeof(FlowDocumentReader), NavigationCommands.DecreaseZoom,
executedHandler, canExecuteHandler, new KeyGesture(Key.OemMinus, ModifierKeys.Control));
}
///
/// Central handler for CanExecute events fired by Commands directed at FlowDocumentReader.
///
/// The target of this Command, expected to be FlowDocumentReader
/// The event arguments for this event.
private static void CanExecuteRoutedEventHandler(object target, CanExecuteRoutedEventArgs args)
{
FlowDocumentReader viewer = target as FlowDocumentReader;
Invariant.Assert(viewer != null, "Target of CanExecuteRoutedEventHandler must be FlowDocumentReader.");
Invariant.Assert(args != null, "args cannot be null.");
// FlowDocumentReader is capable of execution of the majority of its commands.
// Special rules:
// a) during printing only CancelPrint is enabled.
// b) Find command is enabled only when FindToolBar is enabled.
// c) Print command is enabled when Document is attached and printing is enabled.
// d) CancelPrint command is enabled only during printing.
// e) SwitchViewingMode command is enabled if the viewing mode is enabled, or
// the command has no parameters (will switch to the next available view).
if (!viewer._printInProgress)
{
if (args.Command == FlowDocumentReader.SwitchViewingModeCommand)
{
// This command is enabled if the viewing mode is enabled, or the command
// has no parameters (will switch to the next available view).
FlowDocumentReaderViewingMode mode;
if (viewer.ConvertToViewingMode(args.Parameter, out mode))
{
args.CanExecute = viewer.CanSwitchToViewingMode(mode);
}
else
{
args.CanExecute = (args.Parameter == null);
}
}
else if (args.Command == ApplicationCommands.Find)
{
args.CanExecute = viewer.CanShowFindToolBar;
}
else if (args.Command == ApplicationCommands.Print)
{
args.CanExecute = (viewer.Document != null) && viewer.IsPrintEnabled;
}
else if (args.Command == ApplicationCommands.CancelPrint)
{
args.CanExecute = false;
}
else
{
args.CanExecute = true;
}
}
else
{
args.CanExecute = (args.Command == ApplicationCommands.CancelPrint);
}
}
///
/// Central handler for all ExecuteEvents fired by Commands directed at FlowDocumentReader.
///
/// The target of this Command, expected to be FlowDocumentReader.
/// The event arguments associated with this event.
private static void ExecutedRoutedEventHandler(object target, ExecutedRoutedEventArgs args)
{
FlowDocumentReader viewer = target as FlowDocumentReader;
Invariant.Assert(viewer != null, "Target of ExecutedRoutedEventHandler must be FlowDocumentReader.");
Invariant.Assert(args != null, "args cannot be null.");
if (args.Command == FlowDocumentReader.SwitchViewingModeCommand)
{
viewer.TrySwitchViewingMode(args.Parameter);
}
else if (args.Command == ApplicationCommands.Find)
{
viewer.OnFindCommand();
}
else if (args.Command == ApplicationCommands.Print)
{
viewer.OnPrintCommand();
}
else if (args.Command == ApplicationCommands.CancelPrint)
{
viewer.OnCancelPrintCommand();
}
else if (args.Command == NavigationCommands.IncreaseZoom)
{
viewer.OnIncreaseZoomCommand();
}
else if (args.Command == NavigationCommands.DecreaseZoom)
{
viewer.OnDecreaseZoomCommand();
}
else if (args.Command == NavigationCommands.PreviousPage)
{
viewer.OnPreviousPageCommand();
}
else if (args.Command == NavigationCommands.NextPage)
{
viewer.OnNextPageCommand();
}
else if (args.Command == NavigationCommands.FirstPage)
{
viewer.OnFirstPageCommand();
}
else if (args.Command == NavigationCommands.LastPage)
{
viewer.OnLastPageCommand();
}
else
{
Invariant.Assert(false, "Command not handled in ExecutedRoutedEventHandler.");
}
}
///
/// Changes the current viewing mode.
///
private void TrySwitchViewingMode(object parameter)
{
FlowDocumentReaderViewingMode mode;
// Convert command parameter to viewing mode value.
// If parameter is not provided, the viewing mode is the next one available.
// If parameter cannot be converted, the command is ignored.
if (!ConvertToViewingMode(parameter, out mode))
{
if (parameter == null)
{
mode = (FlowDocumentReaderViewingMode)((((int)ViewingMode) + 1) % 3);
}
else
{
return;
}
}
// If the current ViewingMode is disabled, go to next one.
while (!CanSwitchToViewingMode(mode))
{
mode = (FlowDocumentReaderViewingMode)((((int)mode) + 1) % 3);
}
// Set new ViewingMode value.
SetCurrentValueInternal(ViewingModeProperty, mode);
}
///
/// Handler for the PreviousPage command.
///
private void OnPreviousPageCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.PreviousPage();
}
}
///
/// Handler for the NextPage command.
///
private void OnNextPageCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.NextPage();
}
}
///
/// Handler for the FirstPage command.
///
private void OnFirstPageCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.FirstPage();
}
}
///
/// Handler for the LastPage command.
///
private void OnLastPageCommand()
{
if (CurrentViewer != null)
{
CurrentViewer.LastPage();
}
}
///
/// Invoked when the "Find" button in the Find Toolbar is clicked.
/// This method invokes the actual Find process.
///
/// The object that sent this event
/// The Click Events associated with this event
private void OnFindInvoked(object sender, EventArgs e)
{
ITextRange findResult;
TextEditor textEditor = TextEditor;
FindToolBar findToolBar = FindToolBar;
if (findToolBar != null && textEditor != null)
{
// In order to show current text selection TextEditor requires Focus to be set on the UIScope.
// If there embedded controls, it may happen that embedded control currently has focus and find
// was invoked through hotkeys. To support this case we manually move focus to the appropriate element.
if (CurrentViewer != null && CurrentViewer is UIElement)
{
((UIElement)CurrentViewer).Focus();
}
findResult = DocumentViewerHelper.Find(findToolBar, textEditor, textEditor.TextView, textEditor.TextView);
// If we found something, bring it into the view. Otherwise alert the user.
if ((findResult != null) && (!findResult.IsEmpty))
{
// Bring find result into view.
if (CurrentViewer != null)
{
CurrentViewer.ShowFindResult(findResult);
}
}
else
{
DocumentViewerHelper.ShowFindUnsuccessfulMessage(findToolBar);
}
}
}
///
/// Disable commands on IFlowDocumentViewer when this funcionality is explicitly
/// disabled on the reader control.
///
private void PreviewCanExecuteRoutedEventHandler(object target, CanExecuteRoutedEventArgs args)
{
if (args.Command == ApplicationCommands.Find)
{
// Find is handled by FlowDocumentReader.
args.CanExecute = false;
args.Handled = true;
}
else if (args.Command == ApplicationCommands.Print)
{
args.CanExecute = IsPrintEnabled;
args.Handled = !IsPrintEnabled;
}
}
///
/// Called when a key event occurs.
///
private static void KeyDownHandler(object sender, KeyEventArgs e)
{
DocumentViewerHelper.KeyDownHelper(e, ((FlowDocumentReader)sender)._findToolBarHost);
}
#endregion Commands
#region Static Methods
///
/// ViewingMode has been changed.
///
private static void ViewingModeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
if (viewer.CanSwitchToViewingMode((FlowDocumentReaderViewingMode)e.NewValue))
{
viewer.SwitchViewingModeCore((FlowDocumentReaderViewingMode)e.NewValue);
}
else if (viewer.IsInitialized)
{
throw new ArgumentException(SR.Get(SRID.FlowDocumentReaderViewingModeEnabledConflict));
}
// Fire automation events if automation is active.
FlowDocumentReaderAutomationPeer peer = UIElementAutomationPeer.FromElement(viewer) as FlowDocumentReaderAutomationPeer;
if (peer != null)
{
peer.RaiseCurrentViewChangedEvent((FlowDocumentReaderViewingMode)e.NewValue, (FlowDocumentReaderViewingMode)e.OldValue);
}
}
///
/// Validate value of ViewingMode property.
///
private static bool IsValidViewingMode(object o)
{
FlowDocumentReaderViewingMode value = (FlowDocumentReaderViewingMode)o;
return (value == FlowDocumentReaderViewingMode.Page ||
value == FlowDocumentReaderViewingMode.TwoPage ||
value == FlowDocumentReaderViewingMode.Scroll);
}
///
/// One of viewing modes has been enabled/disabled.
///
private static void ViewingModeEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
// Cannot disable all viewing modes.
if (!viewer.IsPageViewEnabled &&
!viewer.IsTwoPageViewEnabled &&
!viewer.IsScrollViewEnabled)
{
throw new ArgumentException(SR.Get(SRID.FlowDocumentReaderCannotDisableAllViewingModes));
}
// Cannot disable the current viewing mode.
if (viewer.IsInitialized && !viewer.CanSwitchToViewingMode(viewer.ViewingMode))
{
throw new ArgumentException(SR.Get(SRID.FlowDocumentReaderViewingModeEnabledConflict));
}
// Fire automation events if automation is active.
FlowDocumentReaderAutomationPeer peer = UIElementAutomationPeer.FromElement(viewer) as FlowDocumentReaderAutomationPeer;
if (peer != null)
{
peer.RaiseSupportedViewsChangedEvent(e);
}
}
///
/// IsFindEnabled value has changed.
///
private static void IsFindEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
// Update the toolbar with our current state.
if (!viewer.CanShowFindToolBar)
{
if (viewer.FindToolBar != null)
{
viewer.ToggleFindToolBar(false);
}
}
// Since IsFindEnabled state is used to determine CanExecute state, we must invalidate that state.
CommandManager.InvalidateRequerySuggested();
}
///
/// IsPrintEnabled value has changed.
///
private static void IsPrintEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
// Since IsPrintEnabled state is used to determine CanExecute state, we must invalidate that state.
CommandManager.InvalidateRequerySuggested();
}
///
/// The Document has changed and needs to be updated.
///
private static void DocumentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
viewer.DocumentChanged((FlowDocument)e.OldValue, (FlowDocument)e.NewValue);
// Since Document state is used to determine CanExecute state, we must invalidate that state.
CommandManager.InvalidateRequerySuggested();
}
///
/// The Zoom has changed and needs to be updated.
///
private static void ZoomChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
if (!DoubleUtil.AreClose((double)e.OldValue, (double)e.NewValue))
{
// If zoom has been changed, CanIncrease/DecreaseZoom property need to be updated.
viewer.SetValue(CanIncreaseZoomPropertyKey, BooleanBoxes.Box(DoubleUtil.GreaterThan(viewer.MaxZoom, viewer.Zoom)));
viewer.SetValue(CanDecreaseZoomPropertyKey, BooleanBoxes.Box(DoubleUtil.LessThan(viewer.MinZoom, viewer.Zoom)));
}
}
///
/// Coerce Zoom with Max/MinZoom, MinZoom works as the baseline.
///
private static object CoerceZoom(DependencyObject d, object value)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
double zoom = (double)value;
double maxZoom = viewer.MaxZoom;
if (DoubleUtil.LessThan(maxZoom, zoom))
{
return maxZoom;
}
double minZoom = viewer.MinZoom;
if (DoubleUtil.GreaterThan(minZoom, zoom))
{
return minZoom;
}
return value;
}
///
/// The MaxZoom has changed and needs to be updated.
///
private static void MaxZoomChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
viewer.CoerceValue(ZoomProperty);
viewer.SetValue(CanIncreaseZoomPropertyKey, BooleanBoxes.Box(DoubleUtil.GreaterThan(viewer.MaxZoom, viewer.Zoom)));
}
///
/// MaxZoom need to be coerced if MinZoom > MaxZoom
///
private static object CoerceMaxZoom(DependencyObject d, object value)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
double min = viewer.MinZoom;
return ((double)value < min) ? min : value;
}
///
/// The MinZoom has changed and needs to be updated.
///
private static void MinZoomChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Invariant.Assert(d != null && d is FlowDocumentReader);
FlowDocumentReader viewer = (FlowDocumentReader)d;
viewer.CoerceValue(MaxZoomProperty);
viewer.CoerceValue(ZoomProperty);
viewer.SetValue(CanDecreaseZoomPropertyKey, BooleanBoxes.Box(DoubleUtil.LessThan(viewer.MinZoom, viewer.Zoom)));
}
///
/// Validate Zoom, MaxZoom, MinZoom and ZoomIncrement value.
///
/// Value to validate.
/// True if the value is valid, false otherwise.
private static bool ZoomValidateValue(object o)
{
double value = (double)o;
return (!Double.IsNaN(value) && !Double.IsInfinity(value) && DoubleUtil.GreaterThan(value, 0d));
}
///
/// PropertyChanged callback for a property that affects the selection or caret rendering.
///
private static void UpdateCaretElement(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
FlowDocumentReader reader = (FlowDocumentReader)d;
if (reader.Selection != null)
{
CaretElement caretElement = reader.Selection.CaretElement;
if (caretElement != null)
{
caretElement.InvalidateVisual();
}
}
}
#endregion Static Methods
#endregion Private Methods
//--------------------------------------------------------------------
//
// Private Properties
//
//-------------------------------------------------------------------
#region Private Properties
///
/// Whether FindToolBar can be enabled.
///
private bool CanShowFindToolBar
{
get { return ((_findToolBarHost != null) && IsFindEnabled && (Document != null)); }
}
///
/// Returns TextEditor, if availabe.
///
private TextEditor TextEditor
{
get
{
TextEditor textEditor = null;
IFlowDocumentViewer currentViewer = CurrentViewer;
if (currentViewer != null && currentViewer.TextSelection != null)
{
textEditor = currentViewer.TextSelection.TextEditor;
}
return textEditor;
}
}
///
/// Returns FindToolBar, if enabled.
///
private FindToolBar FindToolBar
{
get { return (_findToolBarHost != null) ? _findToolBarHost.Child as FindToolBar : null; }
}
///
/// Returns the current content viewer.
///
private IFlowDocumentViewer CurrentViewer
{
get
{
if (_contentHost != null)
{
return (IFlowDocumentViewer)_contentHost.Child;
}
return null;
}
}
#endregion Private Properties
//-------------------------------------------------------------------
//
// Private Fields
//
//-------------------------------------------------------------------
#region Private Fields
private Decorator _contentHost; // Host for content viewer
private Decorator _findToolBarHost; // Host for FindToolBar
private ToggleButton _findButton; // Find toggle button
private ReaderPageViewer _pageViewer; // Viewer for Page viewing mode
private ReaderTwoPageViewer _twoPageViewer; // Viewer for TwoPage viewing mode
private ReaderScrollViewer _scrollViewer; // Viewer for Scroll viewing mode
private bool _documentAsLogicalChild; // Is Document part of logical tree
private bool _printInProgress; // Whether print is currently in progress.
private const string _contentHostTemplateName = "PART_ContentHost"; // Name for ContentHost
private const string _findToolBarHostTemplateName = "PART_FindToolBarHost"; // Name for the Find ToolBar host
private const string _findButtonTemplateName = "FindButton"; // Name for the Find Button
#endregion Private Fields
//--------------------------------------------------------------------
//
// IAddChild Members
//
//-------------------------------------------------------------------
#region IAddChild Members
///
/// Called to add the object as a Child.
///
/// Object to add as a child.
/// FlowDocumentScrollViewer only supports a single child of type IDocumentPaginator.
void IAddChild.AddChild(Object value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
// Check if Content has already been set.
if (this.Document != null)
{
throw new ArgumentException(SR.Get(SRID.FlowDocumentReaderCanHaveOnlyOneChild));
}
if (!(value is FlowDocument))
{
throw new ArgumentException(SR.Get(SRID.UnexpectedParameterType, value.GetType(), typeof(FlowDocument)), "value");
}
Document = value as FlowDocument;
}
///
/// Called when text appears under the tag in markup
///
/// Text to add to the Object.
/// FlowDocumentScrollViewer does not support Text children.
void IAddChild.AddText(string text)
{
XamlSerializerUtil.ThrowIfNonWhiteSpaceInAddText(text, this);
}
#endregion IAddChild Members
//--------------------------------------------------------------------
//
// IJournalState Members
//
//--------------------------------------------------------------------
#region IJournalState Members
[Serializable]
private class JournalState : CustomJournalStateInternal
{
public JournalState(int contentPosition, LogicalDirection contentPositionDirection, double zoom, FlowDocumentReaderViewingMode viewingMode)
{
ContentPosition = contentPosition;
ContentPositionDirection = contentPositionDirection;
Zoom = zoom;
ViewingMode = viewingMode;
}
public int ContentPosition;
public LogicalDirection ContentPositionDirection;
public double Zoom;
public FlowDocumentReaderViewingMode ViewingMode;
}
///
///
CustomJournalStateInternal IJournalState.GetJournalState(JournalReason journalReason)
{
int cp = -1;
LogicalDirection cpDirection = LogicalDirection.Forward;
IFlowDocumentViewer viewer = CurrentViewer;
if (viewer != null)
{
TextPointer contentPosition = viewer.ContentPosition as TextPointer;
if (contentPosition != null)
{
cp = contentPosition.Offset;
cpDirection = contentPosition.LogicalDirection;
}
}
return new JournalState(cp, cpDirection, Zoom, ViewingMode);
}
///
///
void IJournalState.RestoreJournalState(CustomJournalStateInternal state)
{
JournalState viewerState = state as JournalState;
if (state != null)
{
SetCurrentValueInternal(ZoomProperty, viewerState.Zoom);
SetCurrentValueInternal(ViewingModeProperty, viewerState.ViewingMode);
if (viewerState.ContentPosition != -1)
{
IFlowDocumentViewer viewer = CurrentViewer;
FlowDocument document = Document;
if (viewer != null && document != null)
{
TextContainer textContainer = document.StructuralCache.TextContainer;
if (viewerState.ContentPosition <= textContainer.SymbolCount)
{
TextPointer contentPosition = textContainer.CreatePointerAtOffset(viewerState.ContentPosition, viewerState.ContentPositionDirection);
viewer.ContentPosition = contentPosition;
}
}
}
}
}
#endregion IJournalState Members
//-------------------------------------------------------------------
//
// DTypeThemeStyleKey
//
//--------------------------------------------------------------------
#region DTypeThemeStyleKey
///
/// Returns the DependencyObjectType for the registered ThemeStyleKey's default
/// value. Controls will override this method to return approriate types
///
internal override DependencyObjectType DTypeThemeStyleKey
{
get { return _dType; }
}
private static DependencyObjectType _dType;
#endregion DTypeThemeStyleKey
//-------------------------------------------------------------------
//
// Style Keys
//
//-------------------------------------------------------------------
#region Style Keys
///
/// Key used to mark the style for use by the PageView
///
private static ResourceKey PageViewStyleKey
{
get
{
if (_pageViewStyleKey == null)
{
_pageViewStyleKey = new ComponentResourceKey(typeof(PresentationUIStyleResources), "PUIPageViewStyleKey");
}
return _pageViewStyleKey;
}
}
///
/// Key used to mark the style for use by the TwoPageView
///
private static ResourceKey TwoPageViewStyleKey
{
get
{
if (_twoPageViewStyleKey == null)
{
_twoPageViewStyleKey = new ComponentResourceKey(typeof(PresentationUIStyleResources), "PUITwoPageViewStyleKey");
}
return _twoPageViewStyleKey;
}
}
///
/// Key used to mark the style for use by the ScrollView
///
private static ResourceKey ScrollViewStyleKey
{
get
{
if (_scrollViewStyleKey == null)
{
_scrollViewStyleKey = new ComponentResourceKey(typeof(PresentationUIStyleResources), "PUIScrollViewStyleKey");
}
return _scrollViewStyleKey;
}
}
private static ComponentResourceKey _pageViewStyleKey;
private static ComponentResourceKey _twoPageViewStyleKey;
private static ComponentResourceKey _scrollViewStyleKey;
#endregion
}
///
///
public enum FlowDocumentReaderViewingMode
{
///
///
Page,
///
///
TwoPage,
///
///
Scroll
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- SymLanguageVendor.cs
- EntityParameter.cs
- CoreSwitches.cs
- securitycriticaldataClass.cs
- SortKey.cs
- DataGridViewCellContextMenuStripNeededEventArgs.cs
- NGCPageContentSerializerAsync.cs
- NetworkInformationException.cs
- RSAPKCS1SignatureFormatter.cs
- DetectEofStream.cs
- BamlCollectionHolder.cs
- ProxyElement.cs
- PersonalizationStateInfo.cs
- WmlLabelAdapter.cs
- CheckBoxList.cs
- TrackingAnnotationCollection.cs
- TypedElement.cs
- WindowsNonControl.cs
- Pair.cs
- VerificationException.cs
- ExpressionEditorAttribute.cs
- InternalConfigHost.cs
- BookmarkList.cs
- CompensatableTransactionScopeActivity.cs
- MetafileEditor.cs
- StorageSetMapping.cs
- BitmapCodecInfo.cs
- BuiltInPermissionSets.cs
- ToolstripProfessionalRenderer.cs
- OleDbWrapper.cs
- SelectionHighlightInfo.cs
- AbandonedMutexException.cs
- FlowchartDesigner.Helpers.cs
- PrtCap_Public_Simple.cs
- ObjectStateEntryOriginalDbUpdatableDataRecord.cs
- EventMappingSettings.cs
- LateBoundBitmapDecoder.cs
- FlowLayoutSettings.cs
- WasHttpModulesInstallComponent.cs
- sqlstateclientmanager.cs
- X509RawDataKeyIdentifierClause.cs
- NumericUpDownAcceleration.cs
- MetaModel.cs
- DelegateBodyWriter.cs
- GraphicsPathIterator.cs
- SelfIssuedTokenFactoryCredential.cs
- SqlCommand.cs
- EntityDataSourceView.cs
- MimePart.cs
- TableRow.cs
- DSASignatureFormatter.cs
- ConditionChanges.cs
- BinarySerializer.cs
- MethodRental.cs
- ButtonRenderer.cs
- ToolStripComboBox.cs
- Normalization.cs
- CompositionAdorner.cs
- TableLayoutStyleCollection.cs
- HostVisual.cs
- CodeAttributeDeclaration.cs
- ToolTip.cs
- OracleEncoding.cs
- FormsAuthenticationCredentials.cs
- PriorityChain.cs
- ReadWriteSpinLock.cs
- ModifierKeysValueSerializer.cs
- TrackingMemoryStreamFactory.cs
- EventMappingSettingsCollection.cs
- WSIdentityFaultException.cs
- SystemNetHelpers.cs
- ScriptingSectionGroup.cs
- ManipulationStartingEventArgs.cs
- UniqueID.cs
- LeaseManager.cs
- UnaryExpression.cs
- ObjectIDGenerator.cs
- ActiveXHost.cs
- EntityDataSourceStatementEditor.cs
- SourceSwitch.cs
- RawStylusInputReport.cs
- DefaultBinder.cs
- InputReferenceExpression.cs
- SwitchLevelAttribute.cs
- FontDifferentiator.cs
- CustomError.cs
- EmptyElement.cs
- WebPartConnectionsConfigureVerb.cs
- TextRangeEditLists.cs
- DateTimeOffset.cs
- ConcatQueryOperator.cs
- ZipPackage.cs
- BackStopAuthenticationModule.cs
- AdornerLayer.cs
- DelegateBodyWriter.cs
- X509Certificate.cs
- InputScopeManager.cs
- InvalidDocumentContentsException.cs
- SerializationInfoEnumerator.cs
- HtmlProps.cs