/// <summary>
/// 输出报表元素集合
/// </summary>
/// <param name="items">报表元素集合</param>
public void WriteItems(DomElementList items)
{
foreach (DomElement element in items)
{
if (IsVisible(element) == false)
{
continue;
}
if (this.ClipRectangle.IsEmpty == false)
{
RectangleF rect = RectangleF.Intersect(
this.ClipRectangle,
element.AbsBounds);
if (rect.Height >= 2)
{
WriteElement(element);
//element.WriteDocument(this);
}
}
else
{
WriteElement(element);
}
}//foreach
}
public override void WriteHTML(WriterHtmlDocumentWriter writer)
{
if (intListStyle == ParagraphListStyle.BulletedList)
{
writer.WriteStartElement("ul");
}
else
{
writer.WriteStartElement("ol");
}
DomElementList list = WriterUtils.MergeElements(this.Elements, false);
if (list != null && list.Count > 0)
{
foreach (DomElement element in list)
{
if (writer.IncludeSelectionOndly == false ||
element.HasSelection)
{
element.WriteHTML(writer);
}
}
}
writer.WriteEndElement();
}
/// <summary>
/// 初始化对象
/// </summary>
/// <param name="document">文档对象</param>
/// <param name="elements">元素对象列表</param>
/// <param name="startIndex">区域的开始序号</param>
/// <param name="length">区域的长度</param>
public DomRange(DomDocument document, DomElementList elements, int startIndex, int length)
{
_Document = document;
_Elements = elements;
_StartIndex = startIndex;
_Length = length;
_StateInvalidate = true;
}
/// <summary>
/// 修复DOM结构状态
/// </summary>
public override void FixDomState()
{
base.FixDomState();
foreach (DomElement element in this.Elements)
{
element.FixDomState();
}
this._ElementsForSerialize = null;
}
/// <summary>
/// 获得子列表
/// </summary>
/// <param name="startIndex">开始区域位置</param>
/// <param name="length">长度</param>
/// <returns>子列表</returns>
public DomElementList GetRange(int startIndex, int length)
{
DomElementList result = new DomElementList();
for (int iCount = 0; iCount < length; iCount++)
{
result.List.Add(this.List[startIndex + iCount]);
}
return(result);
}
/// <summary>
/// 在指定元素前面插入多个元素
/// </summary>
/// <param name="OldElement">指定的元素</param>
/// <param name="list">要插入的新元素列表</param>
public void InsertRangeBefore(DomElement OldElement, DomElementList list)
{
this.CheckEOF(-1);
int index = this.IndexOf(OldElement);
if (index >= 0)
{
this.InnerList.InsertRange(index, list);
}
}
/// <summary>
/// 插入多个元素
/// </summary>
/// <param name="index">需要插入的位置</param>
/// <param name="list">要插入的元素列表</param>
public void InsertRange(int index, DomElementList list)
{
this.CheckEOF(-1);
if (list != null && list.Count > 0)
{
for (int iCount = 0; iCount < list.Count; iCount++)
{
this.List.Insert(index + iCount, list[iCount]);
}
}
}
public DomElementList DeeplyClone( )
{
this.CheckEOF(-1);
DomElementList list = new DomElementList();
foreach (DomElement element in this)
{
list.Add(element.Clone(true));
}
return(list);
}
/// <summary>
/// 复制对象
/// </summary>
/// <returns>复制品</returns>
object ICloneable.Clone()
{
DomElementList list = (DomElementList)System.Activator.CreateInstance(this.GetType());
list.Clear();
foreach (DomElement element in this)
{
list.List.Add(element);
}
return(list);
}
/// <summary>
/// 获得区域包含的元素列表
/// </summary>
/// <returns>创建的元素列表</returns>
public DomElementList GetElements()
{
CheckState();
DomElementList result = new DomElementList();
for (int iCount = 0; iCount < _Length; iCount++)
{
result.Add(this._Elements[_StartIndex + iCount]);
}
return(result);
}
private void GetContentElements(DomContainerElement rootElement, DomElementList result)
{
foreach (DomElement element in rootElement.Elements)
{
if (element is DomContentElement)
{
result.Add(element);
}
if (element is DomContainerElement)
{
GetContentElements((DomContainerElement)element, result);
}
}
}
/// <summary>
/// 复制对象
/// </summary>
/// <returns>复制品</returns>
public DomElementList Clone()
{
DomElementList list = (DomElementList)System.Activator.CreateInstance(this.GetType());
list.bolCanDeleteEOF = this.bolCanDeleteEOF;
list.bolFastRemoveFlag = this.bolFastRemoveFlag;
list.myEOFElement = this.myEOFElement;
list.myOwnerElement = this.myOwnerElement;
foreach (DomElement e in this)
{
list.Add(e);
}
return(list);
}
private void MyAddRange(DomElementList list, DomElementList content)
{
foreach (DomElement element in content)
{
{
if (list.Contains(element))
{
// 已经添加过内容了，立即退出函数
return;
}
list.Add(element);
}
}
}
/// <summary>
/// 声明指定的元素相关的高亮度显示区域无效,需要重新设置
/// </summary>
/// <param name="element">文档元素对象</param>
/// <param name="deleteElement">由于删除元素操作而执行本方法，
/// 此时不需要将元素添加到高亮度区域状态未知的元素列表</param>
public void InvalidateHighlightInfo(DomElement element)
{
if (element is DomCharElement)
{
// 字符元素不能设置为高亮度区域，因此不处理，提高效率
return;
}
if (_InnerHighlightInfos != null)
{
if (_InvalidateHighlightInfoElements == null)
{
_InvalidateHighlightInfoElements = new DomElementList();
}
if (_InvalidateHighlightInfoElements.Contains(element) == false)
{
_InvalidateHighlightInfoElements.Add(element);
if (_InnerHighlightInfos != null)
{
for (int iCount = _InnerHighlightInfos.Count - 1; iCount >= 0; iCount--)
{
HighlightInfo info = _InnerHighlightInfos[iCount];
bool delete = false;
if (info.OwnerElement == element)
{
delete = true;
}
else if (info.OwnerElement != null &&
info.OwnerElement.IsParentOrSupParent(element))
{
delete = true;
}
if (delete)
{
if (info.Range != null)
{
this.Document.InvalidateView(info.Range);
if (info.OwnerElement != null &&
_InvalidateHighlightInfoElements.Contains(info.OwnerElement) == false)
{
_InvalidateHighlightInfoElements.Add(info.OwnerElement);
}
}
_InnerHighlightInfos.RemoveAt(iCount);
}
} //for
} //if
} //if
}
}
// /// <summary>
// /// 获得指定元素的前一个元素
// /// </summary>
// /// <param name="refElement">指定的元素</param>
// /// <returns>该元素的前一个元素若没找到则返回空</returns>
// public XTextElement GetPreElement( XTextElement refElement)
// {
// int index = this.IndexOf( refElement );
// return SafeGet( index - 1 );
// }
//
// /// <summary>
// /// 获得指定元素的后一个元素
// /// </summary>
// /// <param name="refElement">指定的元素</param>
// /// <returns>该元素的前一个元素，若没有找到则返回空</returns>
// public XTextElement GetNextElement( XTextElement refElement )
// {
// int index = this.IndexOf( refElement );
// if( index >= 0 )
// return SafeGet( index + 1 );
// else
// return null;
// }
/// <summary>
/// 获得子列表
/// </summary>
/// <param name="startIndex">开始元素的序号</param>
/// <param name="length">元素的个数</param>
/// <returns>获得的子列表</returns>
public DomElementList GetElements(int startIndex, int length)
{
if (startIndex <= 0)
{
throw new ArgumentException("startIndex");
}
DomElementList list = new DomElementList();
int endIndex = Math.Min(this.Count - 1, startIndex + length - 1);
for (int iCount = startIndex; iCount <= endIndex; iCount++)
{
list.Add(this[iCount]);
}
return(list);
}
/// <summary>
/// 向类别添加多个对象
/// </summary>
/// <param name="list">多个元素所在的列表</param>
public void AddRange(DomElementList list)
{
this.CheckEOF(-1);
if (list == null || list.Count == 0)
{
return;
}
if (myEOFElement != null)
{
this.InnerList.InsertRange(this.Count - 1, list);
}
else
{
this.InnerList.AddRange(list);
}
}
/// <summary>
/// 将对象拆分成若干个字符元素对象
/// </summary>
/// <returns>拆分所得的字符元素对象列表</returns>
internal DomElementList SplitChars()
{
DomElementList list = new DomElementList();
string txt = myText.ToString();
foreach (char c in txt)
{
DomCharElement NewChar = this.OwnerDocument.CreateChar(c, this.StyleIndex);
if (NewChar != null)
{
NewChar.StyleIndex = this.StyleIndex;
NewChar.Parent = this.Parent;
list.Add(NewChar);
}
}
return(list);
}
/// <summary>
/// 比较两个列表的元素清单是否一致
/// </summary>
/// <param name="list">元素列表</param>
/// <returns>两个对象的元素清单是否一致</returns>
public bool EqualsElements(DomElementList list)
{
this.CheckEOF(-1);
if (list != null && list.Count == this.Count)
{
for (int iCount = 0; iCount < this.Count; iCount++)
{
DomElement element = this[iCount];
if (list[iCount] != element)
{
return(false);
}
}
return(true);
}
return(false);
}
/// <summary>
/// 初始化对象
/// </summary>
/// <param name="container">要替换子元素的容器元素对象</param>
/// <param name="startIndex">替换区域的开始序号</param>
/// <param name="deleteLength">要删除的子元素的个数</param>
/// <param name="newElements">要插入的新元素列表</param>
/// <param name="logUndo">是否记录撤销操作信息</param>
/// <param name="updateContent">是否更新文档视图</param>
/// <param name="raiseEvent">是否触发事件</param>
public ReplaceElementsArgs(
DomContainerElement container,
int startIndex,
int deleteLength,
DomElementList newElements,
bool logUndo,
bool updateContent,
bool raiseEvent)
{
_Container = container;
_StartIndex = startIndex;
_DeleteLength = deleteLength;
_NewElements = newElements;
_LogUndo = logUndo;
_UpdateContent = updateContent;
_RaiseEvent = raiseEvent;
}
/// <summary>
/// 删除元素列表中指定序号后面的元素,并将删除的元素放置到一个新的元素列表中
/// </summary>
/// <param name="index">指定删除开始的序号</param>
/// <returns>放置删除的元素的元素列表</returns>
public DomElementList Split(int index)
{
this.CheckEOF(-1);
DomElementList list = new DomElementList();
int end = this.Count - 1;
if (myEOFElement != null)
{
end--;
}
for (int iCount = end; iCount >= index; iCount--)
{
list.List.Insert(0, this.List[iCount]);
this.RemoveAt(iCount);
}
return(list);
}
internal void RaiseFocusEvent(DomElement oldCurrentElement, DomElement newCurrentElement)
{
DomElementList oldParents = oldCurrentElement == null ?
new DomElementList() : WriterUtils.GetParentList2(oldCurrentElement);
if (oldCurrentElement != null)
{
oldParents.Insert(0, oldCurrentElement);
}
DomElementList newParents = newCurrentElement == null ?
new DomElementList() : WriterUtils.GetParentList2(newCurrentElement);
if (newCurrentElement != null)
{
newParents.Insert(0, newCurrentElement);
}
// 触发旧的容器元素的失去输入焦点事件
foreach (DomElement oldParent in oldParents)
{
if (newParents.Contains(oldParent) == false)
{
//((XTextContainerElement)oldParent).OnLostFocus(this, EventArgs.Empty);
DocumentEventArgs args2 = new DocumentEventArgs(
this.OwnerDocument,
oldParent,
DocumentEventStyles.LostFocus);
oldParent.HandleDocumentEvent(args2);
}
}
// 触发新的容器元素的获得输入焦点事件
foreach (DomElement newParent in newParents)
{
if (oldParents.Contains(newParent) == false)
{
//((XTextContainerElement)newParent).OnGotFocus(this, EventArgs.Empty);
DocumentEventArgs args2 = new DocumentEventArgs(
this.OwnerDocument,
newParent,
DocumentEventStyles.GotFocus);
newParent.HandleDocumentEvent(args2);
}
}
}
protected virtual void WriteContentHTML(WriterHtmlDocumentWriter writer)
{
DomElementList list = WriterUtils.MergeElements(
this.Elements,
true);
if (list != null && list.Count > 0)
{
foreach (DomElement element in list)
{
if (writer.IncludeSelectionOndly == false ||
element.HasSelection)
{
element.WriteHTML(writer);
}
}
}
}
/// <summary>
/// 输出RTF文档
/// </summary>
/// <param name="writer">RTF文档书写器</param>
public override void WriteRTF(DCSoft.CSharpWriter.RTF.RTFContentWriter writer)
{
DomElementList list = WriterUtils.MergeParagraphs(
this.Elements,
writer.IncludeSelectionOnly);
if (list != null && list.Count > 0)
{
foreach (DomElement element in list)
{
//if (writer.IncludeSelectionOnly == false
// || element.HasSelection)
{
element.WriteRTF(writer);
}
}//foreach
}
}
/// <summary>
/// 设置段落样式
/// </summary>
/// <param name="newStyle"></param>
/// <returns></returns>
public DomElementList SetParagraphStyle(DocumentContentStyle newStyle)
{
DomDocument document = this._DocumentContent.OwnerDocument;
Dictionary <DomElement, int> styleIndexs
= new Dictionary <DomElement, int>();
if (this.Document.Options.SecurityOptions.EnablePermission)
{
newStyle.DisableDefaultValue = true;
newStyle.CreatorIndex = this.Document.UserHistories.CurrentIndex;
newStyle.DeleterIndex = -1;
}
else
{
newStyle.DisableDefaultValue = true;
newStyle.CreatorIndex = -1;
newStyle.DeleterIndex = -1;
}
foreach (DomParagraphFlagElement p in this.ParagraphsEOFs)
{
if (document.DocumentControler.CanModify(p))
{
DocumentContentStyle rs = (DocumentContentStyle)p.RuntimeStyle.Clone();
if (XDependencyObject.MergeValues(newStyle, rs, true) > 0)
{
rs.DefaultValuePropertyNames = newStyle.GetDefaultValuePropertyNames();
int newStyleIndex = document.ContentStyles.GetStyleIndex(rs);
if (newStyleIndex != p.StyleIndex)
{
styleIndexs[p] = newStyleIndex;
}
}
}
}//foreach
if (styleIndexs.Count > 0)
{
DomElementList result = document.EditorSetParagraphStyle(styleIndexs, true);
return(result);
}
else
{
return(null);
}
}
/// <summary>
/// 根据内容创建一个新的文档对象,而且不包含已经被逻辑删除的内容.
/// </summary>
/// <returns>创建的文档对象</returns>
public DomDocument CreateDocument()
{
DomDocument document = ( DomDocument )this.Document.Clone(false);
DomDocument sourceDocument = this.Document;
DomContainerElement body = document.Body;
// 寻找所有内容共同的文档容器元素
DomElementList parents1 = WriterUtils.GetParentList(this.ContentElements.FirstElement);
DomElementList parents2 = WriterUtils.GetParentList(this.ContentElements.LastElement);
foreach (DomContainerElement parent in parents1)
{
if (parents2.Contains(parent))
{
DomContentElement ce = parent.ContentElement;
CloneElements(parent, ref body);
break;
}
}
//CloneElements(this.DocumentContent, ref body );
// 删除用户操作历史记录信息
foreach (DocumentContentStyle style in document.ContentStyles.Styles)
{
style.CreatorIndex = -1;
style.DeleterIndex = -1;
}
document.UserHistories.Clear();
// 删除没有引用的样式
document.DeleteUselessStyle();
document.EditorControl = null;
document.DocumentControler = null;
document.HighlightManager = null;
document.EditorCurrentStyle = null;
document.HoverElement = null;
if (document.UndoList != null)
{
document.EndLogUndo();
document.UndoList.Clear();
}
document.FixDomState();
return(document);
}
/// <summary>
/// 快速设置元素的文本内容
/// </summary>
/// <param name="txt">文本</param>
/// <returns>创建的元素对象列表</returns>
public DomElementList SetInnerTextFast(string txt)
{
if (this.Elements == null)
{
this.Elements = new DomElementList();
}
DomElementList list = this.OwnerDocument.CreateTextElements(txt, null, this.Style);
if (list != null && list.Count > 0)
{
this.Elements.Clear();
foreach (DomElement e in list)
{
e.Parent = this;
e.OwnerDocument = this.OwnerDocument;
this.Elements.Add(e);
}
}
return(list);
}
internal bool FixElementsForSerialize(bool deeply)
{
if (_ElementsForSerialize != null && _ElementsForSerialize.Count > 0)
{
this.Elements.Clear();
foreach (DomElement element in _ElementsForSerialize)
{
if (element is DomParagraphElement)
{
this.Elements.AddRange(element.Elements);
}
//else if (element is XTextStringElement)
//{
// XTextStringElement str = (XTextStringElement)element;
// XTextElementList list = str.SplitChars();
// this.Elements.AddRange(list);
//}
else
{
this.Elements.Add(element);
}
}//foreach
_ElementsForSerialize = null;
//WriterUtils.SplitElements(this.Elements);
foreach (DomElement element in this.Elements)
{
element.OwnerDocument = this.OwnerDocument;
element.Parent = this;
if (deeply)
{
if (element is DomContainerElement)
{
((DomContainerElement)element).FixElementsForSerialize(deeply);
}
}
}
return(true);
}
return(false);
}
/// <summary>
/// 将对象内容添加到文档内容中
/// </summary>
/// <param name="content">文档内容对象</param>
/// <returns>添加的文档元素个数</returns>
public virtual int AppendContent(DomElementList content, bool privateMode)
{
int result = 0;
foreach (DomElement element in this.Elements)
{
element.Parent = this;
if (element.Visible)
{
if (element is DomContainerElement)
{
DomContainerElement c = (DomContainerElement)element;
result = result + c.AppendContent(content, privateMode);
}
else
{
content.Add(element);
result++;
}
}//if
} //foreach
return(result);
}
/// <summary>
/// 设置文本
/// </summary>
/// <param name="newText">新文本</param>
/// <param name="flags">标记</param>
/// <param name="disablePermissioin">禁止权限控制</param>
/// <returns>操作是否修改了对象内容</returns>
public bool SetEditorTextExt(string newText, DomAccessFlags flags, bool disablePermissioin, bool updateContent)
{
bool result = false;
if (this.OwnerDocument != null)
{
string oldText = this.Text;
if (oldText == null || oldText != newText)
{
// 为了提高效率，只有出现不同的文本才进行文本替换操作
bool innerLogUndo = this.OwnerDocument.CanLogUndo;
if (innerLogUndo == false)
{
this.OwnerDocument.BeginLogUndo();
}
if (string.IsNullOrEmpty(newText))
{
// 直接设置空内容
ReplaceElementsArgs args = new ReplaceElementsArgs(
this,
0,
this.Elements.Count,
null,
true,
true,
true);
args.DisablePermission = disablePermissioin;
args.AccessFlags = flags;
args.ChangeSelection = false;
args.UpdateContent = updateContent;
if (args.DisablePermission == false &&
this.OwnerDocument.Options.SecurityOptions.EnablePermission)
{
// 很多时候，本属性是为下拉列表文本输入域调用的，此时输入域前面的文本可能是被
// 当前用户输入的，后面的元素已经被逻辑删除了，此时应该应该是执行物理删除，
// 在此进行判断，修正删除区间。
for (int iCount = 0; iCount < this.Elements.Count; iCount++)
{
DomElement element = this.Elements[iCount];
if (element.Style.DeleterIndex >= 0)
{
bool fix = true;
for (int iCount2 = iCount; iCount2 < this.Elements.Count; iCount2++)
{
if (this.Elements[iCount2].Style.DeleterIndex < 0)
{
fix = false;
break;
}
}
if (fix)
{
args.DeleteLength = iCount;
}
break;
}
}//for
}
result = this.OwnerDocument.ReplaceElements(args) != 0;
}
else
{
// 设置文本内容
DomElementList list = this.OwnerDocument.CreateTextElements(newText, null, this.Style);
if (list != null && list.Count > 0)
{
ReplaceElementsArgs args = new ReplaceElementsArgs(
this,
0,
this.Elements.Count,
list,
true,
true,
true);
args.DisablePermission = disablePermissioin;
args.AccessFlags = flags;
args.ChangeSelection = false;
args.UpdateContent = updateContent;
if (args.DisablePermission == false &&
this.OwnerDocument.Options.SecurityOptions.EnablePermission)
{
// 很多时候，本属性是为下拉列表文本输入域调用的，此时输入域前面的文本可能是被
// 当前用户输入的，后面的元素已经被逻辑删除了，此时应该应该是执行物理删除，
// 在此进行判断，修正删除区间。
for (int iCount = 0; iCount < this.Elements.Count; iCount++)
{
DomElement element = this.Elements[iCount];
if (element.Style.DeleterIndex >= 0)
{
bool fix = true;
for (int iCount2 = iCount; iCount2 < this.Elements.Count; iCount2++)
{
if (this.Elements[iCount2].Style.DeleterIndex < 0)
{
fix = false;
break;
}
}
if (fix)
{
args.DeleteLength = iCount;
}
break;
}
}//for
}
result = this.OwnerDocument.ReplaceElements(args) != 0;
}
}
if (innerLogUndo == false)
{
if (result)
{
this.OwnerDocument.EndLogUndo();
}
else
{
this.OwnerDocument.CancelLogUndo();
}
}
if (result)
{
this.OwnerDocument.OnDocumentContentChanged();
this.OwnerDocument.OnSelectionChanged();
}
}
}
else
{
DomElementList list = this.SetInnerTextFast(newText);
result = list != null && list.Count > 0;
}
return(result);
}
/// <summary>
/// 初始化对象
/// </summary>
public DomContainerElement()
{
_Elements = new DomElementList();
_Elements.OwnerElement = this;
}
