/// <summary>Gets the service object of the specified type.</summary>
/// <param name="serviceType">The type of service object to get. </param>
/// <returns>A service object of type <paramref name="serviceType" />, or <see langword="null" /> if there is no service object of type <paramref name="serviceType" />.</returns>
// Token: 0x06005D7B RID: 23931 RVA: 0x001A5254 File Offset: 0x001A3454
protected object GetService(Type serviceType)
{
object result = null;
if (serviceType == null)
{
throw new ArgumentNullException("serviceType");
}
this.CheckDisposed();
if (this._documentPaginator != null && this._documentPaginator is IServiceProvider)
{
if (serviceType == typeof(ITextView))
{
if (this._textView == null)
{
ITextContainer textContainer = ((IServiceProvider)this._documentPaginator).GetService(typeof(ITextContainer)) as ITextContainer;
if (textContainer != null)
{
this._textView = new DocumentPageTextView(this, textContainer);
}
}
result = this._textView;
}
else if (serviceType == typeof(TextContainer) || serviceType == typeof(ITextContainer))
{
result = ((IServiceProvider)this._documentPaginator).GetService(serviceType);
}
}
return(result);
}
internal StaticTextPointer(ITextContainer textContainer, object handle0, int handle1)
{
_textContainer = textContainer;
_generation = (textContainer != null) ? textContainer.Generation : 0;
_handle0 = handle0;
_handle1 = handle1;
}
/// <summary>
/// Returns ITextPointers positioned at the start and end of an element
/// that contains text.
/// </summary>
private bool GetNodesStartAndEnd(DependencyObject startNode, out ITextPointer start, out ITextPointer end)
{
start = null;
end = null;
ITextContainer textContainer = GetTextContainer(startNode);
if (textContainer != null)
{
start = textContainer.Start;
end = textContainer.End;
}
else
{
// Special case for TextElement which doesn't expose its TextContainer
TextElement textElement = startNode as TextElement;
if (textElement != null)
{
start = textElement.ContentStart;
end = textElement.ContentEnd;
}
else
{
return(false);
}
}
return(true);
}
// Token: 0x06007CBC RID: 31932 RVA: 0x00231444 File Offset: 0x0022F644
public void Activate(bool active)
{
if (this._active == active)
{
return;
}
if (this._attachedAnnotation == null)
{
throw new InvalidOperationException(SR.Get("NoAttachedAnnotationToModify"));
}
TextAnchor textAnchor = this._attachedAnnotation.AttachedAnchor as TextAnchor;
Invariant.Assert(textAnchor != null, "AttachedAnchor is not a text anchor");
ITextContainer textContainer = textAnchor.Start.TextContainer;
Invariant.Assert(textContainer != null, "TextAnchor does not belong to a TextContainer");
AnnotationHighlightLayer annotationHighlightLayer = textContainer.Highlights.GetLayer(typeof(HighlightComponent)) as AnnotationHighlightLayer;
Invariant.Assert(annotationHighlightLayer != null, "AnnotationHighlightLayer is not initialized");
annotationHighlightLayer.ActivateRange(this, active);
this._active = active;
if (active)
{
this.HighlightBrush = new SolidColorBrush(this._selectedBackground);
return;
}
this.HighlightBrush = new SolidColorBrush(this._background);
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var italic = new Italic();
parent.Add(italic);
context.RenderNode(element, new SpanContainer(italic));
}
//------------------------------------------------------
//
// Privte Methods
//
//------------------------------------------------------
#region Private Methods
// Private helper that adds a new UIElementPropertyUndoUnit to the undo stack.
private static void AddPrivate(ITextContainer textContainer, UIElement uiElement, DependencyProperty property, object newValue)
{
UndoManager undoManager = TextTreeUndo.GetOrClearUndoManager(textContainer);
if (undoManager == null)
{
return;
}
object currentValue = uiElement.ReadLocalValue(property);
if (currentValue is Expression)
{
// Can't undo when old value is an expression, so clear the stack.
if (undoManager.IsEnabled)
{
undoManager.Clear();
}
return;
}
if (currentValue.Equals(newValue))
{
// No property change.
return;
}
undoManager.Add(new UIElementPropertyUndoUnit(uiElement, property, currentValue));
}
// Token: 0x06007CC6 RID: 31942 RVA: 0x0023171C File Offset: 0x0022F91C
private ITextContainer CheckInputData(IAttachedAnnotation attachedAnnotation)
{
if (attachedAnnotation == null)
{
throw new ArgumentNullException("attachedAnnotation");
}
TextAnchor textAnchor = attachedAnnotation.AttachedAnchor as TextAnchor;
if (textAnchor == null)
{
throw new ArgumentException(SR.Get("InvalidAttachedAnchor"), "attachedAnnotation");
}
ITextContainer textContainer = textAnchor.Start.TextContainer;
Invariant.Assert(textContainer != null, "TextAnchor does not belong to a TextContainer");
if (attachedAnnotation.Annotation == null)
{
throw new ArgumentException(SR.Get("AnnotationIsNull"), "attachedAnnotation");
}
if (!this._type.Equals(attachedAnnotation.Annotation.AnnotationType))
{
throw new ArgumentException(SR.Get("NotHighlightAnnotationType", new object[]
{
attachedAnnotation.Annotation.AnnotationType.ToString()
}), "attachedAnnotation");
}
return(textContainer);
}
/// <summary>
/// Returns the CultureInfoculture of a TextContainer parent.
/// </summary>
private static CultureInfo GetDocumentCultureInfo(ITextContainer textContainer)
{
CultureInfo cultureInfo = null;
if (textContainer.Parent != null)
{
XmlLanguage language = (XmlLanguage)textContainer.Parent.GetValue(FrameworkElement.LanguageProperty);
if (language != null)
{
try
{
cultureInfo = language.GetSpecificCulture();
}
catch (InvalidOperationException)
{
// Someone set a bogus language on the document.
cultureInfo = null;
}
}
}
if (cultureInfo == null)
{
cultureInfo = CultureInfo.CurrentCulture;
}
return(cultureInfo);
}
// Token: 0x06007CB9 RID: 31929 RVA: 0x00231278 File Offset: 0x0022F478
public void AddAttachedAnnotation(IAttachedAnnotation attachedAnnotation)
{
if (this._attachedAnnotation != null)
{
throw new ArgumentException(SR.Get("MoreThanOneAttachedAnnotation"));
}
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.AddAttachedHighlightBegin);
ITextContainer textContainer = this.CheckInputData(attachedAnnotation);
TextAnchor range = attachedAnnotation.AttachedAnchor as TextAnchor;
this.GetColors(attachedAnnotation.Annotation, out this._background, out this._selectedBackground);
this._range = range;
Invariant.Assert(textContainer.Highlights != null, "textContainer.Highlights is null");
AnnotationHighlightLayer annotationHighlightLayer = textContainer.Highlights.GetLayer(typeof(HighlightComponent)) as AnnotationHighlightLayer;
if (annotationHighlightLayer == null)
{
annotationHighlightLayer = new AnnotationHighlightLayer();
textContainer.Highlights.AddLayer(annotationHighlightLayer);
}
this._attachedAnnotation = attachedAnnotation;
this._attachedAnnotation.Annotation.CargoChanged += this.OnAnnotationUpdated;
annotationHighlightLayer.AddRange(this);
this.HighlightBrush = new SolidColorBrush(this._background);
base.IsHitTestVisible = false;
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.AddAttachedHighlightEnd);
}
public void Draw(ITextContainer parent, Matrix baseTransform, FontRenderer renderer, TextCursorPosition cursorPos)
{
renderer.DrawChars(BackgroundText, Width, Height, FormatBack, Dialog, Position.Transform * baseTransform, cursorPos);
var offset = GetBackgroundWidth() - GetForegroundWidth();
renderer.DrawChars(ForegroundText, Width, Height, FormatFront, Dialog, Matrix.CreateTranslation(offset, 0, 0) * Position.Transform * baseTransform, cursorPos);
}
/// <summary>
/// Checks if this attachedAnnotation data - AttachedAnchor and Annotation
/// </summary>
/// <param name="attachedAnnotation">The AttachedAnnotation</param>
/// <returns>The AttachedAnchor TextContainer</returns>
private ITextContainer CheckInputData(IAttachedAnnotation attachedAnnotation)
{
if (attachedAnnotation == null)
{
throw new ArgumentNullException("attachedAnnotation");
}
TextAnchor textAnchor = attachedAnnotation.AttachedAnchor as TextAnchor;
if (textAnchor == null)
{
throw new ArgumentException(SR.Get(SRID.InvalidAttachedAnchor), "attachedAnnotation");
}
//this should be in a fixed or flow textcontainer
ITextContainer textContainer = textAnchor.Start.TextContainer;
Invariant.Assert(textContainer != null, "TextAnchor does not belong to a TextContainer");
if (attachedAnnotation.Annotation == null)
{
throw new ArgumentException(SR.Get(SRID.AnnotationIsNull), "attachedAnnotation");
}
//check annotation type
if (!_type.Equals(attachedAnnotation.Annotation.AnnotationType))
{
throw new ArgumentException(SR.Get(SRID.NotHighlightAnnotationType, attachedAnnotation.Annotation.AnnotationType.ToString()), "attachedAnnotation");
}
return(textContainer);
}
private static void checkMultiValues(
ICollection <SignValueStatement> statements,
ITextContainer result,
ISemanticNetwork semanticNetwork)
{
var clasifications = semanticNetwork.Statements.OfType <IsStatement>().ToList();
foreach (var concept in semanticNetwork.Concepts)
{
var parents = clasifications.GetParentsOneLevel(concept);
foreach (var sign in HasSignStatement.GetSigns(semanticNetwork.Statements, concept, true))
{
if (statements.FirstOrDefault(sv => sv.Concept == concept && sv.Sign == sign.Sign) == null &&
parents.Select(p => SignValueStatement.GetSignValue(semanticNetwork.Statements, p, sign.Sign)).Count(r => r != null) > 1)
{
result.Append(
language => language.GetExtension <ILanguageSetModule>().Statements.Consistency.ErrorMultipleSignValue,
new Dictionary <String, IKnowledge>
{
{ Semantics.Localization.Strings.ParamConcept, concept },
{ Strings.ParamSign, sign.Sign },
});
}
}
}
}
public void Draw(ITextContainer parent, Matrix baseTransform, FontRenderer renderer, TextCursorPosition cursorPos)
{
var sprite = SpriteLoader.Instance.AddSprite("content/ui_slider_bar");
var cursor = SpriteLoader.Instance.AddSprite("content/cursor");
var barSlide = BarSlide();
int bars = (int)Math.Round(BarCount * barSlide);
if (bars <= 0 && barSlide > 0)
{
bars = 1;
}
if (bars >= BarCount - 1 && barSlide < 1)
{
bars = BarCount - 1;
}
renderer.Scene.PushSpriteBatch(transform: Position.Transform * baseTransform);
if (barSlide > 0)
{
renderer.Scene.DrawSprite(cursor, 0, new Vector2(0, 0), SpriteEffects.FlipHorizontally, 0);
}
for (int i = 0; i < BarCount; i++)
{
renderer.Scene.DrawSprite(sprite, 0, new Vector2(16 + i * 5 - 1, 0), SpriteEffects.None, i < bars ? Color.White : Color.Gray, 0);
}
if (barSlide < 1)
{
renderer.Scene.DrawSprite(cursor, 0, new Vector2(16 + BarCount * 5 - 1, 0), SpriteEffects.None, 0);
}
renderer.Scene.PopSpriteBatch();
}
public TextBuilder(float width, float height, TextFormatting defaultFormat = null, DialogFormatting defaultDialog = null)
{
Root = new TextElementContainer(width, height);
ContainerStack.Push(Root);
DefaultFormat = defaultFormat ?? new TextFormatting();
DefaultDialog = defaultDialog ?? new DialogFormattingIdentity();
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var a = (IHtmlAnchorElement)element;
if (a.ChildElementCount == 0)
{
var anchor = new Hyperlink
{
Foreground = new SolidColorBrush(Colors.LightBlue)
};
anchor.Click += async (sender, args) =>
{
var dialog = new MessageDialog(a.Href, "使用浏览器打开");
dialog.Commands.Add(new UICommand("确定", async cmd =>
{
var success = await Launcher.LaunchUriAsync(new Uri(a.Href, UriKind.Absolute));
if (success)
{
anchor.Foreground = new SolidColorBrush(Colors.Purple);
}
}));
dialog.Commands.Add(new UICommand("取消"));
await dialog.ShowAsync();
};
parent.Add(anchor);
context.RenderNode(element, new SpanContainer(anchor));
}
else
{
context.RenderNode(element,parent);
}
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var richEditBox = new RichEditBox();
richEditBox.Document.SetText(TextSetOptions.None, element.TextContent);
parent.Add(richEditBox);
}
/// <summary>
/// Returns service objects associated with this control.
/// This method should be called by IServiceProvider.GetService implementation
/// for DocumentPageView or subclasses.
/// </summary>
/// <param name="serviceType">Specifies the type of service object to get.</param>
protected object GetService(Type serviceType)
{
object service = null;
if (serviceType == null)
{
throw new ArgumentNullException("serviceType");
}
CheckDisposed();
// No service is available if the Content does not provide
// any services.
if (_documentPaginator != null && _documentPaginator is IServiceProvider)
{
// Following services are available:
// (1) TextView - wrapper for TextView exposed by the current page.
// (2) TextContainer - the service object is retrieved from DocumentPaginator.
if (serviceType == typeof(ITextView))
{
if (_textView == null)
{
ITextContainer tc = ((IServiceProvider)_documentPaginator).GetService(typeof(ITextContainer)) as ITextContainer;
if (tc != null)
{
_textView = new DocumentPageTextView(this, tc);
}
}
service = _textView;
}
else if (serviceType == typeof(TextContainer) || serviceType == typeof(ITextContainer))
{
service = ((IServiceProvider)_documentPaginator).GetService(serviceType);
}
}
return service;
}
private float GetAlignmentOffset(ITextContainer parent)
{
float xOffset = 0;
float width = parent.Width;
if (width >= float.PositiveInfinity)
{
width = 0;
}
switch (Alignment)
{
case (LineAlignment.Left):
xOffset = 0;
break;
case (LineAlignment.Center):
xOffset = (width - Width) / 2;
break;
case (LineAlignment.Right):
xOffset = width - Width;
break;
}
return(xOffset);
}
// Token: 0x06007CC9 RID: 31945 RVA: 0x00231834 File Offset: 0x0022FA34
private void OnAnnotationUpdated(object sender, AnnotationResourceChangedEventArgs args)
{
Invariant.Assert(this._attachedAnnotation != null && this._attachedAnnotation.Annotation == args.Annotation, "_attachedAnnotation is different than the input one");
Invariant.Assert(this._range != null, "The highlight range is null");
TextAnchor textAnchor = this._attachedAnnotation.AttachedAnchor as TextAnchor;
Invariant.Assert(textAnchor != null, "wrong anchor type of the saved attached annotation");
ITextContainer textContainer = textAnchor.Start.TextContainer;
Invariant.Assert(textContainer != null, "TextAnchor does not belong to a TextContainer");
Color color;
Color color2;
this.GetColors(args.Annotation, out color, out color2);
if (!this._background.Equals(color) || !this._selectedBackground.Equals(color2))
{
Invariant.Assert(textContainer.Highlights != null, "textContainer.Highlights is null");
AnnotationHighlightLayer annotationHighlightLayer = textContainer.Highlights.GetLayer(typeof(HighlightComponent)) as AnnotationHighlightLayer;
if (annotationHighlightLayer == null)
{
throw new InvalidDataException(SR.Get("MissingAnnotationHighlightLayer"));
}
this._background = color;
this._selectedBackground = color2;
annotationHighlightLayer.ModifiedRange(this);
}
}
public static void Trace(ITextContainer textContainer)
{
if (!Server.Instance.Config.TraceLogDisable)
{
Server.Instance?.Logger.OutputLogger.Trace(textContainer.GetText());
}
}
/// <summary>
/// <see cref="AutomationPeer.GetAutomationControlTypeCore"/>
/// </summary>
public override object GetPattern(PatternInterface patternInterface)
{
object returnValue = null;
if (patternInterface == PatternInterface.Text)
{
if (_textPattern == null)
{
if (Owner is IServiceProvider)
{
ITextContainer textContainer = ((IServiceProvider)Owner).GetService(typeof(ITextContainer)) as ITextContainer;
if (textContainer != null)
{
_textPattern = new TextAdaptor(this, textContainer);
}
}
}
returnValue = _textPattern;
}
else
{
returnValue = base.GetPattern(patternInterface);
}
return(returnValue);
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var paragraph = new Paragraph();
parent.Add(paragraph);
context.RenderNode(element, new OrderListContainer(paragraph));
}
// Returns the local UndoManager.
// Returns null if there is no undo service or if the service exists
// but is disabled or if there is no open parent undo unit.
internal static UndoManager GetOrClearUndoManager(ITextContainer textContainer)
{
UndoManager undoManager;
undoManager = textContainer.UndoManager;
if (undoManager == null)
{
return(null);
}
if (!undoManager.IsEnabled)
{
return(null);
}
if (undoManager.OpenedUnit == null)
{
// There's no parent undo unit, so we can't open a child.
//
// Clear the undo stack -- since we depend on symbol offsets
// matching the original document state when an undo unit is
// executed, any of our units currently in the stack will be
// corrupted after we finished the operation in progress.
undoManager.Clear();
return(null);
}
return(undoManager);
}
internal StaticTextPointer(ITextContainer textContainer, object handle0, int handle1)
{
_textContainer = textContainer;
_generation = (textContainer != null) ? textContainer.Generation : 0;
_handle0 = handle0;
_handle1 = handle1;
}
// ------------------------------------------------------------------
//
// TextSource Implementation
//
// ------------------------------------------------------------------
#region TextSource Implementation
/// <summary>
/// Get a text run at specified text source position and return it.
/// </summary>
/// <param name="dcp">
/// dcp of position relative to start of line
/// </param>
internal override TextRun GetTextRun(int dcp)
{
TextRun run = null;
ITextContainer textContainer = _paraClient.Paragraph.StructuralCache.TextContainer;
StaticTextPointer position = textContainer.CreateStaticPointerAtOffset(_cpPara + dcp);
switch (position.GetPointerContext(LogicalDirection.Forward))
{
case TextPointerContext.Text:
run = HandleText(position);
break;
case TextPointerContext.ElementStart:
run = HandleElementStartEdge(position);
break;
case TextPointerContext.ElementEnd:
run = HandleElementEndEdge(position);
break;
case TextPointerContext.EmbeddedElement:
run = HandleEmbeddedObject(dcp, position);
break;
case TextPointerContext.None:
run = new ParagraphBreakRun(_syntheticCharacterLength, PTS.FSFLRES.fsflrEndOfParagraph);
break;
}
Invariant.Assert(run != null, "TextRun has not been created.");
Invariant.Assert(run.Length > 0, "TextRun has to have positive length.");
return(run);
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var a = (IHtmlAnchorElement)element;
if (a.ChildElementCount == 0)
{
var anchor = new Hyperlink
{
Foreground = new SolidColorBrush(Colors.LightBlue)
};
anchor.Click += async(sender, args) =>
{
var dialog = new MessageDialog(a.Href, "使用浏览器打开");
dialog.Commands.Add(new UICommand("确定", async cmd =>
{
var success = await Launcher.LaunchUriAsync(new Uri(a.Href, UriKind.Absolute));
if (success)
{
anchor.Foreground = new SolidColorBrush(Colors.Purple);
}
}));
dialog.Commands.Add(new UICommand("取消"));
await dialog.ShowAsync();
};
parent.Add(anchor);
context.RenderNode(element, new SpanContainer(anchor));
}
else
{
context.RenderNode(element, parent);
}
}
//--------------------------------------------------------------------
//
// Private Methods
//
//---------------------------------------------------------------------
#region Private Methods
private void _EnsureBlockLoaded()
{
if (_HasStatus(BlockStatus.UnloadedBlock))
{
_ClearStatus(BlockStatus.UnloadedBlock);
DocumentsTrace.FixedDocumentSequence.TextOM.Trace("Loading TextContainer " + _docRef.ToString());
// Load the TextContainer
IDocumentPaginatorSource idp = _docRef.GetDocument(false /*forceReload*/);
IServiceProvider isp = idp as IServiceProvider;
if (isp != null)
{
ITextContainer tc = isp.GetService(typeof(ITextContainer)) as ITextContainer;
if (tc != null)
{
_container = tc;
DocumentsTrace.FixedDocumentSequence.TextOM.Trace("Got ITextContainer");
}
}
if (_container == null)
{
_container = new NullTextContainer();
}
}
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var bold = new Bold();
parent.Add(bold);
context.RenderNode(element, new SpanContainer(bold));
}
/// <summary>
/// Calculate visible rectangle.
/// </summary>
private Rect CalculateBoundingRect(bool clipToVisible, out UIElement uiScope)
{
uiScope = null;
Rect boundingRect = Rect.Empty;
if (Owner is IServiceProvider)
{
ITextContainer textContainer = ((IServiceProvider)Owner).GetService(typeof(ITextContainer)) as ITextContainer;
ITextView textView = (textContainer != null) ? textContainer.TextView : null;
if (textView != null)
{
// Make sure TextView is updated
if (!textView.IsValid)
{
if (!textView.Validate())
{
textView = null;
}
if (textView != null && !textView.IsValid)
{
textView = null;
}
}
// Get bounding rect from TextView.
if (textView != null)
{
boundingRect = new Rect(textView.RenderScope.RenderSize);
uiScope = textView.RenderScope;
// Compute visible portion of the rectangle.
if (clipToVisible)
{
Visual visual = textView.RenderScope;
while (visual != null && boundingRect != Rect.Empty)
{
if (VisualTreeHelper.GetClip(visual) != null)
{
GeneralTransform transform = textView.RenderScope.TransformToAncestor(visual).Inverse;
// Safer version of transform to descendent (doing the inverse ourself),
// we want the rect inside of our space. (Which is always rectangular and much nicer to work with)
if (transform != null)
{
Rect clipBounds = VisualTreeHelper.GetClip(visual).Bounds;
clipBounds = transform.TransformBounds(clipBounds);
boundingRect.Intersect(clipBounds);
}
else
{
// No visibility if non-invertable transform exists.
boundingRect = Rect.Empty;
}
}
visual = VisualTreeHelper.GetParent(visual) as Visual;
}
}
}
}
}
return(boundingRect);
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var span = new Span();
var color = element.Style("color");
if (string.IsNullOrEmpty(color) == false)
{
color = color.Trim().TrimStart('#');
if (color.Length == 6)
{
var sR = color.Substring(0, 2);
var sG = color.Substring(2, 2);
var sB = color.Substring(4, 2);
byte r, g, b;
if (byte.TryParse(sR, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out r) &&
byte.TryParse(sG, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out g) &&
byte.TryParse(sB, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out b))
{
var value = Color.FromArgb(255, r, g, b);
if (value != Colors.White && value != Colors.Black)
{
span.Foreground = new SolidColorBrush(value);
}
}
}
}
parent.Add(span);
context.RenderNode(element, new SpanContainer(span));
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var span = new Span();
parent.Add(span);
context.RenderNode(element, new SpanContainer(span));
}
// Token: 0x06002B48 RID: 11080 RVA: 0x000C5798 File Offset: 0x000C3998
internal ChangeBlockUndoRecord(ITextContainer textContainer, string actionDescription)
{
if (textContainer.UndoManager != null)
{
this._undoManager = textContainer.UndoManager;
if (this._undoManager.IsEnabled)
{
if (textContainer.TextView != null)
{
if (this._undoManager.OpenedUnit == null)
{
if (textContainer.TextSelection != null)
{
this._parentUndoUnit = new TextParentUndoUnit(textContainer.TextSelection);
}
else
{
this._parentUndoUnit = new ParentUndoUnit(actionDescription);
}
this._undoManager.Open(this._parentUndoUnit);
return;
}
}
else
{
this._undoManager.Clear();
}
}
}
}
private static void ParseElement(XmlElement element, ITextContainer parent)
{
foreach (var child in element.ChildNodes)
{
if (child is Windows.Data.Xml.Dom.XmlText)
{
if (string.IsNullOrEmpty(child.InnerText) ||
child.InnerText == "\n")
{
continue;
}
parent.Add(new Run { Text = child.InnerText.Trim(new char[] {'\n'}) });
}
else if (child is XmlElement)
{
XmlElement e = (XmlElement)child;
switch (e.TagName.ToUpper())
{
case "P":
var paragraph = new Paragraph();
parent.Add(paragraph);
ParseElement(e, new ParagraphTextContainer(paragraph));
break;
case "STRONG":
var bold = new Bold();
parent.Add(bold);
ParseElement(e, new SpanTextContainer(bold));
break;
case "U":
var underline = new Underline();
parent.Add(underline);
ParseElement(e, new SpanTextContainer(underline));
break;
case "A":
var inlineElt = new InlineUIContainer();
var hyperlink = new HyperlinkButton();
inlineElt.Child = hyperlink;
hyperlink.Style = (Style)App.Current.Resources["HyperlinkButtonStyle"];
hyperlink.Content = e.InnerText;
hyperlink.Click += delegate(object sender, RoutedEventArgs eventArgs)
{
string uriString = e.GetAttribute("href");
Messenger.Default.Send<LinkClickedMessage>(new LinkClickedMessage()
{
UriToNavigate = uriString
});
};
parent.Add(inlineElt);
//ParseElement(e, parent);
break;
case "BR":
parent.Add(new LineBreak());
break;
}
}
}
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var groupbox = parent as GroupBoxContainer;
if (groupbox != null)
{
groupbox.SetHeader(element.TextContent);
}
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var button = new Button()
{
Content = element.TextContent
};
parent.Add(button);
}
//-------------------------------------------------------------------
//
// Constructors
//
//-------------------------------------------------------------------
#region Constructors
/// <summary>
/// Constructor.
/// </summary>
/// <param name="viewer">Viewer associated with TextView.</param>
/// <param name="renderScope">Render scope - root of layout structure visualizing content.</param>
/// <param name="textContainer">TextContainer representing content.</param>
internal MultiPageTextView(DocumentViewerBase viewer, UIElement renderScope, ITextContainer textContainer)
{
_viewer = viewer;
_renderScope = renderScope;
_textContainer = textContainer;
_pageTextViews = new List<DocumentPageTextView>();
OnPagesUpdatedCore();
}
//-----------------------------------------------------
//
// Constructors
//
//-----------------------------------------------------
#region Constructors
/// <summary>
/// Initialize the TextEditor
/// </summary>
/// <param name="textContainer">
/// TextContainer representing a content to edit.
/// </param>
/// <param name="uiScope">
/// FrameworkElement on which all events for the user interaction will be
/// processed.
/// </param>
/// <param name="isUndoEnabled">
/// If true the TextEditor will enable undo support
/// </param>
internal TextEditor(ITextContainer textContainer, FrameworkElement uiScope, bool isUndoEnabled)
{
// Validate parameters
Invariant.Assert(uiScope != null);
// Set non-zero property defaults.
_acceptsRichContent = true;
// Attach the editor instance to the scope
_textContainer = textContainer;
_uiScope = uiScope;
// Enable undo manager for this uiScope
if (isUndoEnabled && _textContainer is TextContainer)
{
((TextContainer)_textContainer).EnableUndo(_uiScope);
}
// Create TextSelection and link it to text container
_selection = new TextSelection(this);
textContainer.TextSelection = _selection;
// Create DragDropProcess
//
_dragDropProcess = new TextEditorDragDrop._DragDropProcess(this);
// By default we use IBeam cursor
_cursor = Cursors.IBeam;
// Add InputLanguageChanged event handler
TextEditorTyping._AddInputLanguageChangedEventHandler(this);
// Listen to both TextContainer.EndChanging and TextContainer.Changed events
TextContainer.Changed += new TextContainerChangedEventHandler(OnTextContainerChanged);
// Add IsEnabled event handler for cleaning the caret element when uiScope is disabled
_uiScope.IsEnabledChanged += new DependencyPropertyChangedEventHandler(OnIsEnabledChanged);
// Attach this instance of text editor to its uiScope
_uiScope.SetValue(TextEditor.InstanceProperty, this);
// The IsSpellerEnabled property might have been set before this
// TextEditor was instantiated -- check if we need to rev
// up speller support.
if ((bool)_uiScope.GetValue(SpellCheck.IsEnabledProperty))
{
SetSpellCheckEnabled(true);
SetCustomDictionaries(true);
}
// If no IME/TextServices are installed, we have no native reasources
// to clean up at Finalizer.
if (!TextServicesLoader.ServicesInstalled)
{
GC.SuppressFinalize(this);
}
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var paragraph = new Paragraph()
{
TextAlignment = TextAlignment.Center
};
parent.Add(paragraph);
context.RenderNode(element, new ParagraphContainer(paragraph));
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var line = new Rectangle
{
MinWidth = double.MaxValue,
MinHeight = 1,
Fill = new SolidColorBrush(Colors.Gray),
Margin = new Thickness(0, 5, 0, 5)
};
parent.Add(line);
}
internal TextContentRange(int cpFirst, int cpLast, ITextContainer textContainer)
{
Invariant.Assert(cpFirst <= cpLast);
Invariant.Assert(cpFirst >= 0);
Invariant.Assert(textContainer != null);
Invariant.Assert(cpLast <= textContainer.SymbolCount);
_cpFirst = cpFirst;
_cpLast = cpLast;
_size = 0;
_ranges = null;
_textContainer = textContainer;
}
//-------------------------------------------------------------------
//
// Constructors
//
//-------------------------------------------------------------------
#region Constructors
/// <summary>
/// Constructor
/// </summary>
/// <param name="textPeer">Automation Peer representing element for the ui scope of the text</param>
/// <param name="textContainer">ITextContainer</param>
internal TextAdaptor(AutomationPeer textPeer, ITextContainer textContainer)
{
Invariant.Assert(textContainer != null, "Invalid ITextContainer");
Invariant.Assert(textPeer is TextAutomationPeer || textPeer is ContentTextAutomationPeer, "Invalid AutomationPeer");
_textPeer = textPeer;
_textContainer = textContainer;
_textContainer.Changed += new TextContainerChangedEventHandler(OnTextContainerChanged);
if (_textContainer.TextSelection != null)
{
_textContainer.TextSelection.Changed += new EventHandler(OnTextSelectionChanged);
}
}
// Verifies a TextPointer is non-null and is associated with a given TextContainer.
//
// Throws an appropriate exception if a test fails.
internal static void VerifyPosition(ITextContainer container, ITextPointer position, string paramName)
{
if (position == null)
{
throw new ArgumentNullException(paramName);
}
if (position.TextContainer != container)
{
throw new ArgumentException(SR.Get(SRID.NotInAssociatedTree, paramName));
}
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var audio = (IHtmlAudioElement)element;
var mediaElement = new MediaElement
{
Source = new Uri(audio.Source),
AreTransportControlsEnabled = true,
MinHeight = 65
};
parent.Add(mediaElement);
context.RenderNode(element, parent);
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var border = new Border
{
BorderThickness = new Thickness(1),
BorderBrush = new SolidColorBrush(Colors.Gray),
Margin = new Thickness(0, 5, 0, 5),
Padding = new Thickness(10)
};
parent.Add(border);
var richTextBlock = new RichTextBlock();
border.Child = richTextBlock;
context.RenderNode(element, new RichTextBlockContainer(richTextBlock));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="owner">
/// Root of layout structure visualizing content of a page.
/// </param>
/// <param name="textContainer">
/// TextContainer representing content.
/// </param>
internal DocumentPageTextView(FlowDocumentView owner, ITextContainer textContainer)
{
Invariant.Assert(owner != null && textContainer != null);
_owner = owner;
_page = owner.DocumentPage;
_textContainer = textContainer;
// Retrive inner TextView
if (_page is IServiceProvider)
{
_pageTextView = ((IServiceProvider)_page).GetService(typeof(ITextView)) as ITextView;
}
if (_pageTextView != null)
{
_pageTextView.Updated += new EventHandler(HandlePageTextViewUpdated);
}
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var input = (IHtmlInputElement)element;
var type = input.Type ?? string.Empty;
type = type.Trim();
if (type.Length == 0)
{
type = "text";
}
type = type.ToLower();
switch (type)
{
case "text":
{
var textbox = new TextBox
{
Text = input.Value
};
parent.Add(textbox);
break;
}
case "button":
{
var button = new Button
{
Content = input.Value
};
parent.Add(button);
break;
}
default:
{
if (Debugger.IsAttached)
{
Debugger.Break();
}
var textblock = new TextBlock
{
Text = string.Format("input type=\"{0}\" is not support.", input.Type)
};
parent.Add(textblock);
break;
}
}
}
private static void ParseElement(XmlElement element, ITextContainer parent)
{
foreach (var child in element.ChildNodes)
{
if (child is Windows.Data.Xml.Dom.XmlText)
{
if (string.IsNullOrEmpty(child.InnerText) ||
child.InnerText == "\n")
{
continue;
}
parent.Add(new Run { Text = child.InnerText });
}
else if (child is XmlElement)
{
XmlElement e = (XmlElement)child;
switch (e.TagName.ToUpper())
{
case "P":
var paragraph = new Paragraph();
parent.Add(paragraph);
ParseElement(e, new ParagraphTextContainer(paragraph));
break;
case "STRONG":
var bold = new Bold();
parent.Add(bold);
ParseElement(e, new SpanTextContainer(bold));
break;
case "U":
var underline = new Underline();
parent.Add(underline);
ParseElement(e, new SpanTextContainer(underline));
break;
case "A":
ParseElement(e, parent);
break;
case "BR":
parent.Add(new LineBreak());
break;
}
}
}
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var table = (IHtmlTableElement)element;
var grid = new Grid();
foreach (var child in table.Rows)
{
var row = child as IHtmlTableRowElement;
if (row != null)
{
grid.RowDefinitions.Add(new RowDefinition());
int columnCount = 0;
foreach (var column in row.Cells)
{
var richTextBlock = new RichTextBlock()
{
IsTextSelectionEnabled = false
};
var cellRender = new Border()
{
Child = richTextBlock,
Padding = new Thickness(5)
};
context.RenderNode(column, new RichTextBlockContainer(richTextBlock));
Grid.SetColumn(cellRender, columnCount);
Grid.SetRow(cellRender, grid.RowDefinitions.Count - 1);
grid.Children.Add(cellRender);
columnCount++;
if (grid.ColumnDefinitions.Count < columnCount)
{
grid.ColumnDefinitions.Add(new ColumnDefinition());
}
}
}
}
parent.Add(grid);
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
// Constructor, called when a change block is opening.
internal ChangeBlockUndoRecord(ITextContainer textContainer, string actionDescription)
{
if (textContainer.UndoManager != null)
{
_undoManager = textContainer.UndoManager;
if (_undoManager.IsEnabled)
{
// Don't bother opening an undo unit if the owning control is
// still being initialized (ie, programmatic load by parser).
if (textContainer.TextView != null)
{
// Don't bother opening a new undo unit if we're already nested
// inside another.
if (_undoManager.OpenedUnit == null)
{
if (textContainer.TextSelection != null)
{
_parentUndoUnit = new TextParentUndoUnit(textContainer.TextSelection);
}
else
{
_parentUndoUnit = new ParentUndoUnit(actionDescription);
}
_undoManager.Open(_parentUndoUnit);
}
}
else
{
// If the owning control isn't initialized (parser is still running),
// don't add anything to the undo record. Instead, clear it.
_undoManager.Clear();
}
}
}
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
// Verifies a TextPointer is non-null and
// is associated with a given TextContainer.
//
// Throws an appropriate exception if a test fails.
internal static void VerifyPosition(ITextContainer tree, ITextPointer position)
{
VerifyPosition(tree, position, "position");
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var img = (IHtmlImageElement)element;
var source = img.Source;
if (string.IsNullOrEmpty(source))
{
return;
}
var image = new Image
{
Source = new BitmapImage(new Uri(source, UriKind.Absolute))
};
double scale = 1.0;
int? width = img.Width();
if (width.HasValue)
{
if (width.Value > Window.Current.Bounds.Width - 40)
{
scale = (Window.Current.Bounds.Width - 40) / width.Value;
}
image.Width = width.Value * scale;
}
int? height = img.Height();
if (height.HasValue)
{
image.Height = height.Value * scale;
}
DisplayInformation.GetForCurrentView().OrientationChanged +=
(DisplayInformation sender, object args) =>
{
if (sender.CurrentOrientation == DisplayOrientations.Portrait)
{
double scale1 = 1.0;
int? width1 = img.Width();
if (width1.HasValue)
{
if (width1.Value > Window.Current.Bounds.Width - 40)
{
scale1 = (Window.Current.Bounds.Width - 40) / width1.Value;
}
image.Width = width1.Value * scale1;
}
int? height1 = img.Height();
if (height1.HasValue)
{
image.Height = height1.Value * scale1;
}
}
else if (sender.CurrentOrientation == DisplayOrientations.Landscape || sender.CurrentOrientation == DisplayOrientations.LandscapeFlipped)
{
double scale1 = 1.0;
int? width1 = img.Width();
if (width1.HasValue)
{
if (width1.Value > Window.Current.Bounds.Width - 40)
{
scale1 = (Window.Current.Bounds.Width - 40) / width1.Value;
}
image.Width = width1.Value * scale1;
}
int? height1 = img.Height();
if (height1.HasValue)
{
image.Height = height1.Value * scale1;
}
}
};
parent.Add(image);
}
//-----------------------------------------------------
//
// Constructors
//
//-----------------------------------------------------
#region Constructors
internal DeferredTextReference(ITextContainer textContainer)
{
_textContainer = textContainer;
}
//-------------------------------------------------------------------
//
// Constructors
//
//-------------------------------------------------------------------
#region Constructors
/// <summary>
/// Constructor.
/// </summary>
/// <param name="owner">
/// Root of layout structure visualizing content.
/// </param>
/// <param name="textContainer">
/// TextContainer providing content for this view.
/// </param>
internal TextDocumentView(FlowDocumentPage owner, ITextContainer textContainer)
{
_owner = owner;
_textContainer = textContainer;
}
public ParagraphTextContainer(ITextContainer parent, Paragraph block)
{
_block = block;
_parent = parent;
}
public virtual void RenderElement(IElement element, ITextContainer parent, RenderContextBase context)
{
var parentContainer = (parent as RichTextBlockContainer).Get();
Span span = new Span();
Underline underline = null;
var textDecoration = element.Style("text-decoration");
if (!string.IsNullOrEmpty(textDecoration))
{
if (textDecoration == "underline")
{
underline = new Underline();
underline.Inlines.Add(span);
}
}
var color = element.Style("color");
if (string.IsNullOrEmpty(color) == false)
{
color = color.Trim().TrimStart('#');
if (color.Length == 6)
{
var sR = color.Substring(0, 2);
var sG = color.Substring(2, 2);
var sB = color.Substring(4, 2);
byte r, g, b;
if (byte.TryParse(sR, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out r)
&& byte.TryParse(sG, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out g)
&& byte.TryParse(sB, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out b))
{
var value = Color.FromArgb(255, r, g, b);
if (value != Colors.White && value != Colors.Black)
{
if (underline != null)
{
underline.Foreground = new SolidColorBrush(value);
}
else
{
span.Foreground = new SolidColorBrush(value);
}
}
}
}
}
var fontSize = element.Style("font-size");
if (!string.IsNullOrEmpty(fontSize))
{
fontSize = fontSize.Replace("px", "");
if (underline != null)
{
underline.FontSize = double.Parse(fontSize);
}
else
{
span.FontSize = double.Parse(fontSize);
}
}
var fontWeight = element.Style("font-weight");
if (!string.IsNullOrEmpty(fontWeight))
{
if (underline != null)
{
underline.FontWeight = FontWeights.Bold;
}
else
{
span.FontWeight = FontWeights.Bold;
}
}
var textAlign = element.Style("text-align");
if (!string.IsNullOrEmpty(textAlign))
{
if (textAlign == "left")
{
parentContainer.TextAlignment = Windows.UI.Xaml.TextAlignment.Left;
}
else if (textAlign == "right")
{
parentContainer.TextAlignment = Windows.UI.Xaml.TextAlignment.Right;
}
else
{
parentContainer.TextAlignment = Windows.UI.Xaml.TextAlignment.Center;
}
}
var textStyle = element.Style("text-style");
if (!string.IsNullOrEmpty(textStyle))
{
if (textStyle == "italic")
{
if (underline != null)
{
underline.FontStyle = FontStyle.Italic;
}
else
{
span.FontStyle = FontStyle.Italic;
}
}
}
if (underline != null)
{
parent.Add(underline);
context.RenderNode(element, new SpanContainer(underline));
}
else
{
parent.Add(span);
context.RenderNode(element, new SpanContainer(span));
}
}
public void OpenDocument(DocumentId documentId, ITextContainer textContainer)
{
OnDocumentOpened(documentId, textContainer);
}
// Add a new UIElementPropertyUndoUnit to the undo stack for FlowDirection property.
internal static void Add(ITextContainer textContainer, UIElement uiElement, DependencyProperty property, FlowDirection newValue)
{
AddPrivate(textContainer, uiElement, property, newValue);
}
/// <summary>
/// Returns the CultureInfoculture of a TextContainer parent.
/// </summary>
private static CultureInfo GetDocumentCultureInfo(ITextContainer textContainer)
{
CultureInfo cultureInfo = null;
if (textContainer.Parent != null)
{
XmlLanguage language = (XmlLanguage)textContainer.Parent.GetValue(FrameworkElement.LanguageProperty);
if (language != null)
{
try
{
cultureInfo = language.GetSpecificCulture();
}
catch (InvalidOperationException)
{
// Someone set a bogus language on the document.
cultureInfo = null;
}
}
}
if (cultureInfo == null)
{
cultureInfo = CultureInfo.CurrentCulture;
}
return cultureInfo;
}
// Returns the local UndoManager.
// Returns null if there is no undo service or if the service exists
// but is disabled or if there is no open parent undo unit.
internal static UndoManager GetOrClearUndoManager(ITextContainer textContainer)
{
UndoManager undoManager;
undoManager = textContainer.UndoManager;
if (undoManager == null)
return null;
if (!undoManager.IsEnabled)
return null;
if (undoManager.OpenedUnit == null)
{
// There's no parent undo unit, so we can't open a child.
//
// Clear the undo stack -- since we depend on symbol offsets
// matching the original document state when an undo unit is
// executed, any of our units currently in the stack will be
// corrupted after we finished the operation in progress.
undoManager.Clear();
return null;
}
return undoManager;
}
//------------------------------------------------------
//
// Privte Methods
//
//------------------------------------------------------
#region Private Methods
// Private helper that adds a new UIElementPropertyUndoUnit to the undo stack.
private static void AddPrivate(ITextContainer textContainer, UIElement uiElement, DependencyProperty property, object newValue)
{
UndoManager undoManager = TextTreeUndo.GetOrClearUndoManager(textContainer);
if (undoManager == null)
{
return;
}
object currentValue = uiElement.ReadLocalValue(property);
if (currentValue is Expression)
{
// Can't undo when old value is an expression, so clear the stack.
if (undoManager.IsEnabled)
{
undoManager.Clear();
}
return;
}
if (currentValue.Equals(newValue))
{
// No property change.
return;
}
undoManager.Add(new UIElementPropertyUndoUnit(uiElement, property, currentValue));
}