411 lines
63 KiB
C#
411 lines
63 KiB
C#
using System;甀猀椀渀最 匀礀猀琀攀洀⸀䌀漀氀氀攀挀琀椀漀渀猀⸀䜀攀渀攀爀椀挀㬀ഀ
|
||
using System.Text;甀猀椀渀最 匀礀猀琀攀洀⸀圀椀渀搀漀眀猀⸀䘀漀爀洀猀㬀ഀ
|
||
using System.Text.RegularExpressions;甀猀椀渀最 匀礀猀琀攀洀⸀䐀爀愀眀椀渀最㬀ഀ
|
||
渀愀洀攀猀瀀愀挀攀 嘀䔀倀刀伀䴀匀⸀䌀匀䰀䄀⸀䰀椀戀爀愀爀礀ഀ
|
||
{ऀ瀀甀戀氀椀挀 挀氀愀猀猀 䐀椀猀瀀氀愀礀吀攀砀琀ഀ
|
||
{ऀऀ⌀爀攀最椀漀渀 倀爀漀瀀攀爀琀椀攀猀ഀ
|
||
private ItemInfo _MyItemInfo;ऀऀ⼀⼀ 氀椀猀琀 漀昀 ✀瀀椀攀挀攀猀 漀昀 琀攀砀琀✀ 昀漀爀 琀栀椀猀 椀琀攀洀⸀ 倀椀攀挀攀猀 椀渀挀氀甀搀攀 猀礀洀戀漀氀猀Ⰰ 爀漀猀Ⰰ ഀ
|
||
// transitions & plain text.ऀऀ瀀爀椀瘀愀琀攀 䰀椀猀琀㰀搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀㸀 开䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀㬀ഀ
|
||
public List<displayTextElement> DisplayTextElementListऀऀ笀ഀ
|
||
get { return _DisplayTextElementList; }ऀऀऀ猀攀琀 笀 开䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀 㴀 瘀愀氀甀攀㬀 紀ഀ
|
||
}ऀऀ⼀⼀ 搀椀挀琀椀漀渀愀爀礀 昀漀爀 琀栀攀 昀漀渀琀 琀愀戀氀攀 昀漀爀 琀栀椀猀 椀琀攀洀⸀ 一漀琀攀 琀栀愀琀 琀栀椀猀 洀愀礀ഀ
|
||
// go away (it is not really used).ऀऀ瀀爀椀瘀愀琀攀 䐀椀挀琀椀漀渀愀爀礀㰀椀渀琀Ⰰ 猀琀爀椀渀最㸀 开搀椀挀刀琀昀䘀漀渀琀吀愀戀氀攀㬀ഀ
|
||
public Dictionary<int, string> dicRtfFontTableऀऀ笀ഀ
|
||
get { return _dicRtfFontTable; }ऀऀऀ猀攀琀 笀 开搀椀挀刀琀昀䘀漀渀琀吀愀戀氀攀 㴀 瘀愀氀甀攀㬀 紀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 嘀䔀开䘀漀渀琀 开琀攀砀琀䘀漀渀琀㬀ऀऀ⼀⼀ 䘀漀渀琀 昀爀漀洀 昀漀爀洀愀琀 昀漀爀 琀栀椀猀 椀琀攀洀ഀ
|
||
public VE_Font TextFontऀऀ笀ഀ
|
||
get { return _textFont; }ऀऀ 猀攀琀 笀 开琀攀砀琀䘀漀渀琀 㴀 瘀愀氀甀攀㬀 紀ഀ
|
||
}ऀऀ瀀甀戀氀椀挀 猀琀爀椀渀最 伀爀椀最椀渀愀氀吀攀砀琀㬀ऀऀ⼀⼀ 挀漀洀瀀愀爀攀 昀漀爀 猀愀瘀攀 琀漀 猀攀攀 椀昀 挀栀愀渀最攀⸀ഀ
|
||
public string OriginalConfigText;ऀऀ瀀爀椀瘀愀琀攀 䘀漀爀洀愀琀䤀渀昀漀 开䴀礀䘀漀爀洀愀琀㬀ഀ
|
||
#endregionऀऀ⌀爀攀最椀漀渀 䌀漀渀猀琀爀甀挀琀漀爀猀ഀ
|
||
/// <summary>ऀऀ⼀⼀⼀ 䐀椀猀瀀氀愀礀吀攀砀琀 挀漀渀猀琀爀甀挀琀漀爀㨀ഀ
|
||
/// Creates a DisplayText object that converts the database text into a list of ऀऀ⼀⼀⼀ऀऀऀऀ搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀 攀氀攀洀攀渀琀猀⸀ഀ
|
||
/// Arguments are:ऀऀ⼀⼀⼀ऀऀऀऀ䤀琀攀洀䤀渀昀漀 椀琀攀洀䤀渀昀漀 ⴀ 琀栀攀 椀琀攀洀 眀栀漀猀攀 琀攀砀琀 眀椀氀氀 戀攀 爀攀猀漀氀瘀攀搀ഀ
|
||
/// E_EditPrintMode ep_mode - edit or print.ऀऀ⼀⼀⼀ऀऀऀऀ䔀开嘀椀攀眀䴀漀搀攀 瘀眀开洀漀搀攀 ⴀ 瘀椀攀眀 漀爀 攀搀椀琀⸀ഀ
|
||
/// </summary>ऀऀ瀀甀戀氀椀挀 䐀椀猀瀀氀愀礀吀攀砀琀⠀䤀琀攀洀䤀渀昀漀 椀琀攀洀䤀渀昀漀Ⰰ 䔀开䔀搀椀琀倀爀椀渀琀䴀漀搀攀 攀瀀䴀漀搀攀Ⰰ 䔀开嘀椀攀眀䴀漀搀攀 瘀眀䴀漀搀攀⤀ഀ
|
||
{ऀऀऀ开䴀礀䤀琀攀洀䤀渀昀漀 㴀 椀琀攀洀䤀渀昀漀㬀ഀ
|
||
DisplayTextElementList = new List<displayTextElement>();ऀऀऀ伀爀椀最椀渀愀氀吀攀砀琀 㴀 椀琀攀洀䤀渀昀漀⸀䴀礀䌀漀渀琀攀渀琀⸀吀攀砀琀㬀ഀ
|
||
TextFont = GetItemFont();ऀऀऀ猀琀爀椀渀最 琀攀砀琀 㴀 开䴀礀䤀琀攀洀䤀渀昀漀⸀䴀礀䌀漀渀琀攀渀琀⸀吀攀砀琀㬀ഀ
|
||
ऀऀऀ⼀⼀ 椀昀 椀渀 瀀爀椀渀琀 洀漀搀攀 漀爀 瘀椀攀眀 洀漀搀攀Ⰰ 搀漀 爀攀瀀氀愀挀攀 眀漀爀搀猀⸀ 伀渀氀礀 椀昀 椀渀 攀搀椀琀 洀漀搀攀 愀爀攀 爀攀瀀氀愀挀攀ഀ
|
||
// words left as is.ऀऀऀ开䴀礀䘀漀爀洀愀琀 㴀 椀琀攀洀䤀渀昀漀⸀䄀挀琀椀瘀攀䘀漀爀洀愀琀㬀ഀ
|
||
if (epMode == E_EditPrintMode.Print || vwMode == E_ViewMode.View) text = DoReplaceWords(text);ഀ
|
||
// as a precaution, convert any \~ to \u160?. This is for Hard spaces.. see the commentary in theऀऀऀ⼀⼀ 猀愀瘀攀 瀀漀爀琀椀漀渀 漀昀 琀栀椀猀 挀漀搀攀 昀漀爀 愀渀 攀砀瀀氀愀渀愀琀椀漀渀⸀ഀ
|
||
text = text.Replace(@"\~", @"\u160?");ഀ
|
||
// replace the dash/hyphen or whatever you want to call it, with a hard hyphen. The 16-bit programऀऀऀ⼀⼀ 琀爀攀愀琀攀搀 琀栀攀 搀愀猀栀⼀栀礀瀀栀攀渀 愀猀 猀甀挀栀⸀ 吀爀愀渀猀氀愀琀攀 戀愀挀欀 漀渀 愀渀礀 搀愀琀愀 猀愀瘀攀猀⸀ഀ
|
||
text = text.Replace(@"-", @"\u8209?");ഀ
|
||
// displayTextElement List items are created for anything that is handled differently in RTB, i.e.ऀऀऀ⼀⼀ 猀礀洀戀漀氀猀Ⰰ 爀漀猀Ⰰ 琀爀愀渀猀Ⰰ 琀攀砀琀⸀ഀ
|
||
int startIndex = 0;ऀऀऀ椀渀琀 椀渀搀攀砀 㴀 ⴀ㬀ഀ
|
||
while ((index = FindTokenChar(text, startIndex))>-1)ऀऀऀ笀ഀ
|
||
// Do any 'plain' text that preceeds the token.ऀऀऀऀ椀昀 ⠀椀渀搀攀砀 㸀 猀琀愀爀琀䤀渀搀攀砀⤀ 䐀漀吀攀砀琀䔀氀攀洀攀渀琀⠀琀攀砀琀Ⰰ 猀琀愀爀琀䤀渀搀攀砀Ⰰ 椀渀搀攀砀⤀㬀ഀ
|
||
ऀऀऀऀ⼀⼀ 一漀眀 搀漀 愀渀礀 漀琀栀攀爀 琀礀瀀攀猀ഀ
|
||
if (text[index] == '\x15')ऀऀऀऀऀ椀渀搀攀砀 㴀 䐀漀刀伀⠀琀攀砀琀Ⰰ 椀渀搀攀砀⤀㬀ഀ
|
||
else if (text[index] == '\x252C' || text[index]=='\x2566')ऀऀऀऀऀ椀渀搀攀砀 㴀 䐀漀吀爀愀渀⠀琀攀砀琀Ⰰ 椀渀搀攀砀⤀㬀ഀ
|
||
elseऀऀऀऀऀ椀渀搀攀砀 㴀 䐀漀匀礀洀戀漀氀⠀琀攀砀琀Ⰰ 猀琀愀爀琀䤀渀搀攀砀Ⰰ 椀渀搀攀砀⤀㬀ഀ
|
||
startIndex = index; // +1;ऀऀऀऀ椀昀 ⠀猀琀愀爀琀䤀渀搀攀砀 㸀㴀 琀攀砀琀⸀䰀攀渀最琀栀⤀ 戀爀攀愀欀㬀ഀ
|
||
}ऀऀऀ⼀⼀ 䄀搀搀 愀渀礀 爀攀洀愀椀渀椀渀最 琀攀砀琀⸀ഀ
|
||
if (startIndex < text.Length) DoTextElement(text, startIndex, index);ऀऀ紀ഀ
|
||
#endregionऀऀ⌀爀攀最椀漀渀 匀愀瘀攀䐀愀琀愀ഀ
|
||
public bool Save(RichTextBox rtb)ऀऀ笀ഀ
|
||
tryऀऀऀ笀ഀ
|
||
List<displayLinkElement> origList = GetLinkList(DisplayTextElementList);ऀऀऀऀ⼀⼀ 洀愀猀猀愀最攀 猀琀爀椀渀最 琀漀 猀琀漀爀攀 椀渀 䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀⸀⸀⸀ഀ
|
||
RtfToDisplayTextElements(rtb);ऀऀऀऀ⼀⼀ 琀愀欀攀 琀栀攀 氀椀猀琀 ☀ 挀漀渀瘀攀爀琀 琀漀 搀愀琀愀 椀渀 琀栀攀 昀漀爀洀愀琀 琀漀 猀愀瘀攀 琀漀 琀栀攀 搀愀琀愀戀愀猀攀⸀ഀ
|
||
StringBuilder sret = new StringBuilder();ऀऀऀऀ昀漀爀攀愀挀栀 ⠀搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀 瘀琀攀 椀渀 䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀⤀ഀ
|
||
{ऀऀऀऀऀ椀昀 ⠀瘀琀攀⸀吀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀吀攀砀琀 簀簀 瘀琀攀⸀吀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀匀礀洀戀漀氀⤀ഀ
|
||
sret.Append(vte.Text);ऀऀऀऀऀ攀氀猀攀 椀昀 ⠀瘀琀攀⸀吀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀刀攀昀攀爀攀渀挀攀搀伀戀樀攀挀琀⤀ഀ
|
||
sret.Append(ToData_RO((displayLinkElement)vte));ऀऀऀऀऀ攀氀猀攀 椀昀 ⠀瘀琀攀⸀吀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀吀爀愀渀猀椀琀椀漀渀 簀簀 瘀琀攀⸀吀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀吀爀愀渀猀椀琀椀漀渀刀愀渀最攀⤀ഀ
|
||
sret.Append(ToData_Trans((displayLinkElement)vte));ऀऀऀऀ紀ഀ
|
||
string modtext = sret.ToString();ऀऀऀऀഀ
|
||
if (modtext != OriginalText)ऀऀऀऀ笀ഀ
|
||
Item itm = _MyItemInfo.Get();ऀऀऀऀऀ⼀⼀ 挀栀攀挀欀 昀漀爀 搀椀昀昀攀爀攀渀琀 琀攀砀琀Ⰰ 椀⸀攀⸀ 琀攀砀琀 昀爀漀洀 琀栀椀猀 椀琀洀 搀漀攀猀渀✀琀 洀愀琀挀栀ഀ
|
||
// original text.ऀऀऀऀऀ椀昀 ⠀伀爀椀最椀渀愀氀吀攀砀琀 ℀㴀 椀琀洀⸀䴀礀䌀漀渀琀攀渀琀⸀吀攀砀琀⤀ഀ
|
||
{ऀऀऀऀऀऀ䌀漀渀猀漀氀攀⸀圀爀椀琀攀䰀椀渀攀⠀∀匀愀瘀攀 䘀愀椀氀攀搀 戀攀挀愀甀猀攀 琀攀砀琀 挀栀愀渀最攀搀 漀甀琀猀椀搀攀 漀昀 琀栀椀猀 攀搀椀琀 猀攀猀猀椀漀渀⸀∀⤀㬀ഀ
|
||
return false;ऀऀऀऀऀ紀ഀ
|
||
// Compare ro/transition lists and delete or add any to the item for any ros/transitions that have beenऀऀऀऀऀ⼀⼀ 愀搀搀攀搀⼀搀攀氀攀琀攀搀 漀爀 洀漀搀椀昀椀攀搀⸀ഀ
|
||
ProcessRoTranChanges(itm, origList);ऀऀऀऀऀ椀琀洀⸀䴀礀䌀漀渀琀攀渀琀⸀吀攀砀琀 㴀 洀漀搀琀攀砀琀㬀ഀ
|
||
itm.Save();ऀऀऀऀऀ伀爀椀最椀渀愀氀吀攀砀琀 㴀 洀漀搀琀攀砀琀㬀ഀ
|
||
}ऀऀऀऀ攀氀猀攀ഀ
|
||
return true; // no text changed, but did not fail so return true.ऀऀऀ紀ഀ
|
||
catch (Exception ex)ऀऀऀ笀ഀ
|
||
Console.WriteLine("Save Failed with error: {0}", ex.Message);ऀऀऀऀ爀攀琀甀爀渀 昀愀氀猀攀㬀ഀ
|
||
}ऀऀऀ爀攀琀甀爀渀 琀爀甀攀㬀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 瘀漀椀搀 倀爀漀挀攀猀猀刀漀吀爀愀渀䌀栀愀渀最攀猀⠀䤀琀攀洀 椀琀洀Ⰰ 䰀椀猀琀㰀搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀㸀 漀爀椀最䰀椀猀琀⤀ഀ
|
||
{ऀऀऀ⼀⼀ 最漀 琀栀爀漀甀最栀 氀椀猀琀⸀ 一漀琀攀 琀栀愀琀 漀渀氀礀 氀椀渀欀攀搀 椀琀攀洀猀 愀爀攀 椀渀 琀栀攀 漀爀椀最䰀椀猀琀⸀ഀ
|
||
// 1) delete any that are in origList but not in the DisplayTextElementListऀऀऀ⼀⼀ऀऀ⠀琀栀愀琀 爀攀瀀爀攀猀攀渀琀猀 琀栀攀 挀甀爀爀攀渀琀 琀攀砀琀 ☀ 氀椀渀欀猀⤀ഀ
|
||
// 2) add any that are only in DisplayTextElementListऀऀऀ⼀⼀ऀ㌀⤀ऀ搀攀氀攀琀攀⼀愀搀搀 昀漀爀 洀漀搀椀昀礀㼀ഀ
|
||
ऀऀऀ⼀⼀ 搀攀氀攀琀攀 昀椀爀猀琀 ⴀ 椀昀 椀渀 漀爀椀最椀渀愀氀Ⰰ 戀甀琀 渀漀琀 椀渀 挀甀爀爀攀渀琀 氀椀猀琀Ⰰ 搀攀氀攀琀攀 琀栀攀 漀渀攀ഀ
|
||
// in the original list.ऀऀऀ昀漀爀攀愀挀栀 ⠀搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀 漀搀琀攀 椀渀 漀爀椀最䰀椀猀琀⤀ഀ
|
||
{ऀऀऀऀ戀漀漀氀 昀漀甀渀搀 㴀 昀愀氀猀攀㬀ഀ
|
||
foreach (displayTextElement dte in DisplayTextElementList)ऀऀऀऀ笀ഀ
|
||
if (dte.Type == odte.Type)ऀऀऀऀऀ笀ഀ
|
||
displayLinkElement l_dte = (displayLinkElement)dte;ऀऀऀऀऀऀ椀昀 ⠀漀搀琀攀⸀䰀椀渀欀 㴀㴀 氀开搀琀攀⸀䰀椀渀欀⤀ഀ
|
||
{ऀऀऀऀऀऀऀ昀漀甀渀搀 㴀 琀爀甀攀㬀ഀ
|
||
break;ऀऀऀऀऀऀ紀ഀ
|
||
}ऀऀऀऀ紀ഀ
|
||
// remove the link element from the item.ऀऀऀऀ椀昀 ⠀℀昀漀甀渀搀⤀ഀ
|
||
{ऀऀऀऀऀ⼀⼀ 䜀攀琀 爀攀挀漀爀搀 椀搀 昀漀爀 爀漀 漀爀 琀爀愀渀猀 愀渀搀 琀栀攀渀 昀椀渀搀 琀栀攀 愀猀猀漀挀椀愀琀攀搀 爀漀 漀爀 琀爀愀渀猀椀琀椀漀渀ഀ
|
||
// in the item's list. remove it.ऀऀऀऀऀ椀渀琀 爀攀挀椀搀 㴀 ⴀ㬀ഀ
|
||
if (odte.Type != E_TextElementType.ReferencedObject)ऀऀऀऀऀ笀ഀ
|
||
int sp = odte.Link.IndexOf(" ") + 1; // get past tran typeऀऀऀऀऀऀ猀琀爀椀渀最 猀爀攀挀椀搀 㴀 漀搀琀攀⸀䰀椀渀欀⸀匀甀戀猀琀爀椀渀最⠀猀瀀Ⰰ 漀搀琀攀⸀䰀椀渀欀⸀䤀渀搀攀砀伀昀⠀∀ ∀Ⰰ 猀瀀⤀ ⴀ 猀瀀⤀㬀ഀ
|
||
recid = System.Convert.ToInt32(srecid);ऀऀऀऀऀऀ昀漀爀攀愀挀栀 ⠀䌀漀渀琀攀渀琀吀爀愀渀猀椀琀椀漀渀 挀琀 椀渀 椀琀洀⸀䴀礀䌀漀渀琀攀渀琀⸀䌀漀渀琀攀渀琀吀爀愀渀猀椀琀椀漀渀猀⤀ഀ
|
||
{ऀऀऀऀऀऀऀ椀昀 ⠀挀琀⸀吀爀愀渀猀椀琀椀漀渀䤀䐀 㴀㴀 爀攀挀椀搀⤀ഀ
|
||
{ऀऀऀऀऀऀऀऀ椀琀洀⸀䴀礀䌀漀渀琀攀渀琀⸀䌀漀渀琀攀渀琀吀爀愀渀猀椀琀椀漀渀猀⸀刀攀洀漀瘀攀⠀挀琀⤀㬀ഀ
|
||
break;ऀऀऀऀऀऀऀ紀ഀ
|
||
}ऀऀऀऀऀ紀ഀ
|
||
elseऀऀऀऀऀ笀ഀ
|
||
int sp = odte.Link.IndexOf(" "); ऀऀऀऀऀऀ⼀⼀爀漀甀猀愀最攀椀搀 猀琀愀爀琀猀 愀昀琀攀爀 ∀⌀䰀椀渀欀㨀刀攀昀攀爀攀渀挀攀搀伀戀樀攀挀琀㨀∀Ⰰ 椀⸀攀⸀ 椀渀搀攀砀 椀渀 氀椀渀欀 漀昀 ㈀㌀ഀ
|
||
string srecid = odte.Link.Substring(23, sp-23);ऀऀऀऀऀऀ爀攀挀椀搀 㴀 匀礀猀琀攀洀⸀䌀漀渀瘀攀爀琀⸀吀漀䤀渀琀㌀㈀⠀猀爀攀挀椀搀⤀㬀ഀ
|
||
foreach (ContentRoUsage cr in itm.MyContent.ContentRoUsages)ऀऀऀऀऀऀ笀ഀ
|
||
if (cr.ROUsageID == recid)ऀऀऀऀऀऀऀ笀ഀ
|
||
itm.MyContent.ContentRoUsages.Remove(cr);ऀऀऀऀऀऀऀऀ戀爀攀愀欀㬀ഀ
|
||
}ऀऀऀऀऀऀ紀ഀ
|
||
}ऀऀऀऀ紀ഀ
|
||
}ऀऀऀ⼀⼀ 渀漀眀 搀漀 椀渀猀攀爀琀Ⰰ 椀⸀攀⸀ 椀渀 渀攀眀 氀椀猀琀Ⰰ 戀甀琀 渀漀琀 椀渀 漀氀搀⸀ഀ
|
||
foreach (displayTextElement dte in DisplayTextElementList)ऀऀऀ笀ഀ
|
||
bool found = false;ऀऀऀऀ椀昀 ⠀搀琀攀⸀吀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀刀攀昀攀爀攀渀挀攀搀伀戀樀攀挀琀 簀簀 搀琀攀⸀吀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀吀爀愀渀猀椀琀椀漀渀 簀簀 搀琀攀⸀吀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀吀爀愀渀猀椀琀椀漀渀刀愀渀最攀⤀ഀ
|
||
{ऀऀऀऀऀ昀漀爀攀愀挀栀 ⠀搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀 漀搀琀攀 椀渀 漀爀椀最䰀椀猀琀⤀ഀ
|
||
{ऀऀऀऀऀऀ椀昀 ⠀搀琀攀⸀吀礀瀀攀 㴀㴀 漀搀琀攀⸀吀礀瀀攀⤀ഀ
|
||
{ऀऀऀऀऀऀऀ⼀⼀ 椀昀 琀栀攀 氀椀渀欀 椀猀 琀栀攀 猀愀洀攀Ⰰ 椀琀 攀砀椀猀琀猀Ⰰ 猀漀 渀漀 愀挀琀椀漀渀 椀猀 爀攀焀甀椀爀攀搀⸀ഀ
|
||
displayLinkElement l_dte = (displayLinkElement)dte;ऀऀऀऀऀऀऀ椀昀 ⠀漀搀琀攀⸀䰀椀渀欀 㴀㴀 氀开搀琀攀⸀䰀椀渀欀⤀ഀ
|
||
{ऀऀऀऀऀऀऀऀ昀漀甀渀搀 㴀 琀爀甀攀㬀ഀ
|
||
break;ऀऀऀऀऀऀऀ紀ഀ
|
||
}ऀऀऀऀऀ紀ഀ
|
||
// Insert the link (ro or transition) to the itemऀऀऀऀऀ椀昀 ⠀℀昀漀甀渀搀⤀ഀ
|
||
{ऀऀऀऀऀऀ椀昀 ⠀搀琀攀⸀吀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀刀攀昀攀爀攀渀挀攀搀伀戀樀攀挀琀⤀ ⼀⼀ 搀漀 爀漀ഀ
|
||
{ऀऀऀऀऀऀऀ搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀 氀开搀琀攀 㴀 ⠀搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀⤀搀琀攀㬀ഀ
|
||
Match m = Regex.Match(l_dte.Link, ".*[#]Link:([A-Za-z]*):(.*)");ऀऀऀऀऀऀऀ⼀⼀开刀漀唀猀愀最攀椀搀 㴀 洀⸀䜀爀漀甀瀀猀嬀㈀崀⸀嘀愀氀甀攀㬀ഀ
|
||
//_Roid = m.Groups[3].Value;ऀऀऀऀऀऀऀ猀琀爀椀渀最 氀椀渀欀猀琀爀 㴀 洀⸀䜀爀漀甀瀀猀嬀㈀崀⸀嘀愀氀甀攀㬀ഀ
|
||
if (linkstr[0] == ' ') linkstr = linkstr.Substring(1, linkstr.Length - 1);ऀऀऀऀऀऀऀ椀渀琀 爀漀椀搀椀渀搀砀 㴀 氀椀渀欀猀琀爀⸀䤀渀搀攀砀伀昀⠀∀ ∀Ⰰ ⤀⬀㬀ഀ
|
||
string roid = linkstr.Substring(roidindx, linkstr.Length - roidindx);ऀऀऀऀऀऀऀ⼀⼀ 吀伀䐀伀㨀 䬀䈀刀 刀伀䘀匀吀 ⴀ 渀攀攀搀 琀漀 愀搀搀 爀漀搀戀 䌀漀渀琀攀渀琀刀漀唀猀愀最攀 挀爀 㴀 椀琀洀⸀䴀礀䌀漀渀琀攀渀琀⸀䌀漀渀琀攀渀琀刀漀唀猀愀最攀猀⸀䄀搀搀⠀爀漀椀搀⤀㬀ഀ
|
||
//int rouऀऀऀऀऀऀऀ⼀⼀椀渀琀 琀爀椀搀 㴀 挀琀⸀吀爀愀渀猀椀琀椀漀渀䤀䐀㬀ഀ
|
||
break; ऀऀऀऀऀऀ紀ഀ
|
||
else if (dte.Type == E_TextElementType.TransitionRange || dte.Type == E_TextElementType.Transition)ऀऀऀऀऀऀ笀ഀ
|
||
displayLinkElement l_dte = (displayLinkElement)dte;ऀऀऀऀऀऀऀ䴀愀琀挀栀 洀 㴀 刀攀最攀砀⸀䴀愀琀挀栀⠀氀开搀琀攀⸀䰀椀渀欀Ⰰ ∀⸀⨀嬀⌀崀䰀椀渀欀㨀⠀嬀䄀ⴀ娀愀ⴀ稀崀⨀⤀㨀⠀⸀⨀⤀∀⤀㬀ഀ
|
||
string linkstr = m.Groups[2].Value;ऀऀऀऀऀऀऀ椀昀 ⠀氀椀渀欀猀琀爀嬀 崀 㴀㴀 ✀ ✀⤀ 氀椀渀欀猀琀爀 㴀 氀椀渀欀猀琀爀⸀匀甀戀猀琀爀椀渀最⠀Ⰰ 氀椀渀欀猀琀爀⸀䰀攀渀最琀栀 ⴀ ⤀㬀ഀ
|
||
int type = System.Convert.ToInt32(linkstr.Substring(0,1));ऀऀऀऀऀऀऀ椀渀琀 琀爀椀渀搀砀 㴀 氀椀渀欀猀琀爀⸀䤀渀搀攀砀伀昀⠀∀ ∀Ⰰ ㈀⤀㬀 ⼀⼀ 猀琀愀爀琀 瀀愀猀琀 琀栀攀 猀瀀愀挀攀 愀昀琀攀爀 琀栀攀 琀礀瀀攀⸀ഀ
|
||
int trindx2 = linkstr.IndexOf(" ", trindx + 1);ऀऀऀऀऀऀऀ椀昀 ⠀琀爀椀渀搀砀㈀ 㴀㴀 ⴀ⤀ 琀爀椀渀搀砀㈀ 㴀 氀椀渀欀猀琀爀⸀䰀攀渀最琀栀 ⴀ 㬀ഀ
|
||
int tr1 = System.Convert.ToInt32(linkstr.Substring(trindx + 1, trindx2 - trindx));ऀऀऀऀऀऀऀ䤀琀攀洀 椀琀洀 㴀 䤀琀攀洀⸀䜀攀琀⠀琀爀⤀㬀ഀ
|
||
int tr2 = 0;ऀऀऀऀऀऀऀ䤀琀攀洀 椀琀洀㈀ 㴀 渀甀氀氀㬀ഀ
|
||
if (dte.Type == E_TextElementType.TransitionRange)ऀऀऀऀऀऀऀ笀ഀ
|
||
tr2 = System.Convert.ToInt32(linkstr.Substring(trindx2,linkstr.Length-trindx2));ऀऀऀऀऀऀऀऀ椀琀洀㈀ 㴀 䤀琀攀洀⸀䜀攀琀⠀琀爀㈀⤀㬀 ഀ
|
||
}ऀऀऀऀऀऀऀ䌀漀渀琀攀渀琀吀爀愀渀猀椀琀椀漀渀 挀琀 㴀 椀琀洀⸀䴀礀䌀漀渀琀攀渀琀⸀䌀漀渀琀攀渀琀吀爀愀渀猀椀琀椀漀渀猀⸀䄀搀搀⠀椀琀洀Ⰰ 椀琀洀㈀⤀㬀ഀ
|
||
ct.TranType = type;ऀऀऀऀऀऀऀ椀渀琀 琀爀椀搀 㴀 挀琀⸀吀爀愀渀猀椀琀椀漀渀䤀䐀㬀ഀ
|
||
}ऀऀऀऀऀ紀ഀ
|
||
}ऀऀऀ紀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 䰀椀猀琀㰀搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀㸀 䜀攀琀䰀椀渀欀䰀椀猀琀⠀䰀椀猀琀㰀搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀㸀 氀漀挀䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀⤀ഀ
|
||
{ऀऀऀ䰀椀猀琀㰀搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀㸀 爀攀琀䰀椀猀琀 㴀 渀攀眀 䰀椀猀琀㰀搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀㸀⠀⤀㬀ഀ
|
||
foreach (displayTextElement vte in locDisplayTextElementList)ऀऀऀ笀ഀ
|
||
if (vte.Type == E_TextElementType.ReferencedObject || vte.Type == E_TextElementType.TransitionRange || vte.Type == E_TextElementType.Transition)ऀऀऀऀ笀ഀ
|
||
displayLinkElement tmp = (displayLinkElement)vte;ऀऀऀऀऀ搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀 挀漀瀀礀开瘀琀攀 㴀 渀攀眀 搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀⠀⤀㬀ഀ
|
||
copy_vte.Type = tmp.Type;ऀऀऀऀऀ挀漀瀀礀开瘀琀攀⸀䰀椀渀欀 㴀 琀洀瀀⸀䰀椀渀欀㬀ഀ
|
||
copy_vte.Text = tmp.Text;ऀऀऀऀऀ爀攀琀䰀椀猀琀⸀䄀搀搀⠀挀漀瀀礀开瘀琀攀⤀㬀ഀ
|
||
}ऀऀऀ紀ഀ
|
||
return retList;ऀऀ紀ഀ
|
||
private void RtfToDisplayTextElements(RichTextBox rtb)ऀऀ笀ഀ
|
||
// For hardspaces, the windows richtextbox does some 'quirky' things:ऀऀऀ⼀⼀ 䄀 甀渀椀挀漀搀攀 爀攀瀀爀攀猀攀渀琀愀琀椀漀渀 漀昀 尀甀㘀 㼀 椀猀 猀攀渀琀 䤀一吀伀 琀栀攀 爀琀戀⸀ 䌀漀洀椀渀最 漀甀琀Ⰰ ഀ
|
||
// that \u160? was translated to a \~ (by the underlying windows rtb).ऀऀऀ⼀⼀ 一漀琀攀 琀栀愀琀 椀昀 琀栀攀 尀縀 椀猀 猀攀渀琀 琀漀 琀栀攀 爀琀戀Ⰰ 椀琀 椀猀 琀爀攀愀琀攀搀 愀猀 愀 爀攀最甀氀愀爀 猀瀀愀挀攀Ⰰഀ
|
||
// i.e. no longer a hardspace, and actually is converted to a regular space.ऀऀऀ⼀⼀ 匀伀Ⰰ 漀渀 琀栀攀 眀愀礀 漀甀琀Ⰰ 挀漀渀瘀攀爀琀 愀渀礀 尀縀 琀漀 尀甀㘀 㼀ഀ
|
||
string noExtraRtfStr = rtb.Rtf.Replace(@"\~", @"\u160?");ഀ
|
||
ऀऀऀ⼀⼀ 䜀攀琀䘀漀渀琀吀愀戀氀攀 爀攀琀甀爀渀猀 愀 渀漀渀ⴀ渀攀最愀琀椀瘀攀 渀甀洀戀攀爀 昀漀渀琀 渀甀洀戀攀爀 椀渀 琀栀攀ഀ
|
||
// font table for the unicode font, if it is used (otherwise -1)ऀऀऀ⼀⼀椀渀琀 甀渀椀挀漀搀攀䘀漀渀琀 㴀 䜀攀琀䘀漀渀琀吀愀戀氀攀⠀爀琀戀⸀刀琀昀⤀㬀ഀ
|
||
ऀऀऀ⼀⼀ 猀琀爀椀瀀 漀昀昀 愀氀氀 爀琀昀 挀漀洀洀愀渀搀猀⸀⸀⸀ഀ
|
||
noExtraRtfStr = StripRtfCommands(noExtraRtfStr);ऀऀऀ⼀⼀䌀漀渀猀漀氀攀⸀圀爀椀琀攀䰀椀渀攀⠀∀匀琀爀椀瀀刀琀昀㨀 笀 紀∀Ⰰ 渀漀䔀砀琀爀愀刀琀昀匀琀爀⤀㬀ഀ
|
||
ऀऀऀ⼀⼀ 䄀氀猀漀Ⰰ 猀攀琀 戀愀挀欀 琀栀攀 栀愀爀搀 搀愀猀栀 琀漀 愀 爀攀最甀氀愀爀 搀愀猀栀⸀⸀⸀ 䐀漀 琀栀椀猀 愀昀琀攀爀 琀栀攀 爀攀洀漀瘀愀氀ഀ
|
||
// of other rtf commands though since the \u8209 was surrounded by font commandsऀऀऀ⼀⼀ 琀栀愀琀Ⰰ 眀椀琀栀漀甀琀 琀栀攀爀攀 爀攀洀漀瘀愀氀 昀椀爀猀琀Ⰰ 眀愀猀 愀氀猀漀 爀攀洀漀瘀椀渀最 琀栀攀 搀愀猀栀⸀ 䠀愀瘀攀 椀琀 眀椀琀栀 ഀ
|
||
// a space & without because if it is at the end, there will be no space (leaveऀऀऀ⼀⼀ 椀琀 琀漀 爀琀昀 瀀爀漀挀攀猀猀椀渀最 琀漀 洀愀欀攀 椀琀 洀漀爀攀 挀漀洀瀀氀椀挀愀琀攀搀⤀ഀ
|
||
noExtraRtfStr = noExtraRtfStr.Replace(@"\u8209? ", @"-");ऀऀऀ渀漀䔀砀琀爀愀刀琀昀匀琀爀 㴀 渀漀䔀砀琀爀愀刀琀昀匀琀爀⸀刀攀瀀氀愀挀攀⠀䀀∀尀甀㠀㈀ 㤀㼀∀Ⰰ 䀀∀ⴀ∀⤀㬀ഀ
|
||
ऀऀऀ䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀⸀䌀氀攀愀爀⠀⤀㬀ഀ
|
||
int startIndex = 0;ऀऀऀ椀渀琀 椀渀搀攀砀 㴀 ⴀ㬀ഀ
|
||
while ((index = FindRtfChar(noExtraRtfStr, startIndex)) > -1)ऀऀऀ笀ഀ
|
||
int fndindx = -1;ऀऀऀऀ⼀⼀ 䐀漀 愀渀礀 ✀瀀氀愀椀渀✀ 琀攀砀琀 琀栀愀琀 瀀爀攀挀攀攀搀猀 琀栀攀 琀漀欀攀渀⸀ഀ
|
||
if (index > startIndex)ऀऀऀऀऀ椀渀搀攀砀 㴀 匀愀瘀攀吀攀砀琀䔀氀攀洀攀渀琀⠀渀漀䔀砀琀爀愀刀琀昀匀琀爀Ⰰ 猀琀愀爀琀䤀渀搀攀砀Ⰰ 椀渀搀攀砀⤀㬀ഀ
|
||
if ((fndindx = noExtraRtfStr.IndexOf(@"\protect",index)) == index)ऀऀऀऀऀ椀渀搀攀砀 㴀 匀愀瘀攀䰀椀渀欀⠀渀漀䔀砀琀爀愀刀琀昀匀琀爀Ⰰ 椀渀搀攀砀⤀㬀ഀ
|
||
elseऀऀऀऀऀ椀渀搀攀砀 㴀 匀愀瘀攀匀礀洀戀漀氀吀䔀⠀渀漀䔀砀琀爀愀刀琀昀匀琀爀Ⰰ 椀渀搀攀砀⤀㬀ഀ
|
||
startIndex = index + 1;ऀऀऀऀ椀昀 ⠀猀琀愀爀琀䤀渀搀攀砀 㸀㴀 渀漀䔀砀琀爀愀刀琀昀匀琀爀⸀䰀攀渀最琀栀⤀ 戀爀攀愀欀㬀ഀ
|
||
}ऀऀऀ⼀⼀ 䄀搀搀 愀渀礀 爀攀洀愀椀渀椀渀最 琀攀砀琀⸀ഀ
|
||
if (startIndex < noExtraRtfStr.Length) DoTextElement(noExtraRtfStr, startIndex, index);ऀऀऀ⼀⼀䌀漀渀猀漀氀攀⸀圀爀椀琀攀䰀椀渀攀⠀渀漀䔀砀琀爀愀刀琀昀匀琀爀⤀㬀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 椀渀琀 匀愀瘀攀吀攀砀琀䔀氀攀洀攀渀琀⠀猀琀爀椀渀最 搀愀琀愀Ⰰ 椀渀琀 猀琀愀爀琀䤀渀搀攀砀Ⰰ 椀渀琀 椀渀搀攀砀⤀ഀ
|
||
{ऀऀऀ搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀 瘀琀攀 㴀 渀攀眀 搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀⠀⤀㬀ഀ
|
||
vte.Type = E_TextElementType.Text;ऀऀऀ椀渀琀 氀攀渀 㴀 ⠀椀渀搀攀砀 㴀㴀 ⴀ⤀ 㼀 搀愀琀愀⸀䰀攀渀最琀栀 ⴀ 猀琀愀爀琀䤀渀搀攀砀 㨀 椀渀搀攀砀 ⴀ 猀琀愀爀琀䤀渀搀攀砀㬀ഀ
|
||
vte.Text = data.Substring(startIndex, len);ऀऀऀ䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀⸀䄀搀搀⠀瘀琀攀⤀㬀ഀ
|
||
return index;ऀऀ紀ഀ
|
||
private int SaveSymbolTE(string data, int startIndex)ऀऀ笀ഀ
|
||
displayLinkElement vte = new displayLinkElement();ऀऀऀ瘀琀攀⸀吀礀瀀攀 㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀匀礀洀戀漀氀㬀ഀ
|
||
// symbols are just the unicode/rtf command, no font associated with itऀऀऀ⼀⼀ 戀礀 琀栀攀 琀椀洀攀 椀琀 最攀琀猀 栀攀爀攀⸀⸀⸀ 䄀 猀礀洀戀漀氀 挀愀渀 戀攀 爀攀瀀爀攀猀攀渀琀攀搀 戀礀 尀✀砀礀 漀爀 尀甀砀礀稀㼀ഀ
|
||
// if the \'xy is used the length of the symbol number will always be two,ऀऀऀ⼀⼀ 漀琀栀攀爀眀椀猀攀 昀椀渀搀 琀栀攀 椀渀搀攀砀 漀昀 琀栀攀 ✀㼀✀ 琀漀 昀椀渀搀 琀栀攀 攀渀搀⸀ഀ
|
||
int endindx = -1;ऀऀऀ椀昀 ⠀搀愀琀愀嬀猀琀愀爀琀䤀渀搀攀砀 ⬀ 崀 㴀㴀 ✀尀✀✀⤀ 攀渀搀椀渀搀砀 㴀 猀琀愀爀琀䤀渀搀攀砀 ⬀ ㌀㬀ഀ
|
||
else endindx = data.IndexOf("?", startIndex);ऀऀऀ椀昀 ⠀攀渀搀椀渀搀砀 㴀㴀 ⴀ⤀ 爀攀琀甀爀渀 猀琀愀爀琀䤀渀搀攀砀㬀 ⼀⼀ 渀漀琀 昀漀甀渀搀 ⴀ 攀爀爀漀爀ഀ
|
||
vte.Text = data.Substring(startIndex, endindx - startIndex + 1);ऀऀऀ䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀⸀䄀搀搀⠀瘀琀攀⤀㬀ഀ
|
||
if (endindx+1<data.Length && data[endindx + 1] != ' ') return endindx;ऀऀऀ爀攀琀甀爀渀 攀渀搀椀渀搀砀 ⬀ 㬀ऀ⼀⼀ 愀搀搀 漀渀攀 琀漀 最攀琀 瀀愀猀琀 琀栀攀 猀瀀愀挀攀 琀栀愀琀 眀愀猀 愀搀搀攀搀 愀昀琀攀爀 愀 猀礀洀戀漀氀 ⠀琀漀 攀渀搀 琀栀攀 昀漀渀琀 挀洀搀⤀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 椀渀琀 匀愀瘀攀䰀椀渀欀⠀猀琀爀椀渀最 搀愀琀愀Ⰰ 椀渀琀 猀琀䤀渀搀攀砀⤀ഀ
|
||
{ऀऀऀ⼀⼀搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀 瘀琀攀 㴀 渀攀眀 搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀⠀⤀㬀ഀ
|
||
// find the end of the link text, i.e. either the ending \v0 or \protect0. The win32 rtf box canऀऀऀ⼀⼀ 瀀甀琀 琀栀攀猀攀 椀渀 攀椀琀栀攀爀 漀爀搀攀爀Ⰰ 琀愀欀攀 琀栀攀 氀漀眀攀猀琀 椀渀搀攀砀⸀ഀ
|
||
int startIndex = stIndex + @"\protect ".Length;ऀऀऀ椀渀琀 椀渀搀砀开瘀 㴀 搀愀琀愀⸀䤀渀搀攀砀伀昀⠀䀀∀尀瘀 ∀Ⰰ 猀琀愀爀琀䤀渀搀攀砀⤀㬀ഀ
|
||
int indx_protect0 = data.IndexOf(@"\protect0", startIndex);ऀऀऀ椀渀琀 椀渀搀砀 㴀 椀渀搀砀开瘀 㰀椀渀搀砀开瀀爀漀琀攀挀琀 㼀椀渀搀砀开瘀 㨀椀渀搀砀开瀀爀漀琀攀挀琀 㬀ഀ
|
||
LinkText lt = new LinkText(data.Substring(startIndex,indx-startIndex));ऀऀऀ搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀 瘀琀攀 㴀 渀攀眀 搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀⠀⤀㬀ഀ
|
||
vte.Type = (E_TextElementType)lt.MyParsedLinkType;ऀऀऀ瘀琀攀⸀吀攀砀琀 㴀 氀琀⸀䴀礀嘀愀氀甀攀㬀ഀ
|
||
vte.Link = lt.MyLink;ऀऀऀ䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀⸀䄀搀搀⠀瘀琀攀⤀㬀ഀ
|
||
return (indx_v0<indx_protect0?indx_protect0+1:indx_v0+1);ऀऀ紀ഀ
|
||
//private int SaveTranTE(string data, int startIndex, E_TextElementType type)ऀऀ⼀⼀笀ഀ
|
||
// displayLinkElement vte = new displayLinkElement();ऀऀऀഀ
|
||
// vte.Type = type;ऀऀ⼀⼀ ⼀⼀ 尀瀀爀漀琀攀挀琀 笀琀爀愀渀猀椀琀椀漀渀 琀攀砀琀紀 尀瘀 ⌀䰀椀渀欀㨀吀爀愀渀猀椀琀椀漀渀⠀刀愀渀最攀⤀㨀 ㈀ ㌀尀瀀爀漀琀攀挀琀 尀瘀 ഀ
|
||
// // where 1 2 3 are transition type and idsऀऀ⼀⼀ 椀渀琀 椀渀搀砀 㴀 搀愀琀愀⸀䤀渀搀攀砀伀昀⠀∀尀尀瘀 ⌀䰀椀渀欀㨀吀爀愀渀猀椀琀椀漀渀∀Ⰰ 猀琀愀爀琀䤀渀搀攀砀⤀㬀ഀ
|
||
// // use '9' to get past \\protectऀऀ⼀⼀ 瘀琀攀⸀吀攀砀琀 㴀 搀愀琀愀⸀匀甀戀猀琀爀椀渀最⠀猀琀愀爀琀䤀渀搀攀砀 ⬀ 㤀Ⰰ 椀渀搀砀 ⴀ 猀琀愀爀琀䤀渀搀攀砀 ⴀ 㤀⤀㬀ഀ
|
||
// // the link is the text between the #Link... and the next '\\'.ऀऀ⼀⼀ 椀渀琀 椀攀渀搀 㴀 搀愀琀愀⸀䤀渀搀攀砀伀昀⠀∀尀尀∀Ⰰ 椀渀搀砀⬀⤀㬀ഀ
|
||
// int bindx = data.IndexOf("#", indx);ऀऀ⼀⼀ 瘀琀攀⸀䰀椀渀欀 㴀 搀愀琀愀⸀匀甀戀猀琀爀椀渀最⠀戀椀渀搀砀Ⰰ 椀攀渀搀 ⴀ 戀椀渀搀砀⤀㬀ऀऀऀ ഀ
|
||
// DisplayTextElementList.Add(vte);ऀऀ⼀⼀ ⼀⼀ 甀渀昀漀爀琀甀渀愀琀攀氀礀Ⰰ 琀栀攀 爀琀昀 戀漀砀 洀愀礀 愀搀搀 琀栀攀 尀瀀爀漀琀攀挀琀 尀瘀 椀渀 攀椀琀栀攀爀 漀爀搀攀爀ഀ
|
||
// // and with or without one or more spaces between then. The number of textऀऀ⼀⼀ ⼀⼀ 挀栀愀爀愀挀琀攀爀猀 㴀 昀漀爀 尀瀀爀漀琀攀挀琀 尀瘀 ⴀ 昀椀渀搀 琀栀攀 渀甀洀戀攀爀 漀昀 猀瀀愀挀攀猀 戀攀琀眀攀攀渀 琀栀攀洀ഀ
|
||
// // if any?ऀऀ⼀⼀ 椀渀琀 渀猀瀀 㴀 㬀ഀ
|
||
// for (int c = iend; c < iend + 11; c++) if (data[c] == ' ') nsp++;ऀऀ⼀⼀ 爀攀琀甀爀渀 椀攀渀搀 ⬀ ⬀ 渀猀瀀㬀ഀ
|
||
//}ऀऀ⼀⼀瀀爀椀瘀愀琀攀 椀渀琀 匀愀瘀攀刀伀吀䔀⠀猀琀爀椀渀最 搀愀琀愀Ⰰ 椀渀琀 猀琀愀爀琀䤀渀搀攀砀⤀ഀ
|
||
//{ऀऀ⼀⼀ 搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀 瘀琀攀 㴀 渀攀眀 搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀⠀⤀㬀ഀ
|
||
// vte.Type = E_TextElementType.ReferencedObject;ऀऀ⼀⼀ ⼀⼀ 尀瀀爀漀琀攀挀琀 笀爀漀瘀愀氀甀攀紀 尀瘀 ⌀䰀椀渀欀㨀刀攀昀攀爀攀渀挀攀搀伀戀樀攀挀琀 ⠀刀漀唀猀愀最攀䤀搀⤀ 笀刀伀䤀䐀紀尀瀀爀漀琀攀挀琀 尀瘀 ഀ
|
||
// int indx = data.IndexOf("\\v #Link:ReferencedObject", startIndex);ऀऀ⼀⼀ ⼀⼀ 甀猀攀 ✀㤀✀ 琀漀 最攀琀 瀀愀猀琀 尀尀瀀爀漀琀攀挀琀ഀ
|
||
// vte.Text = data.Substring(startIndex + 9, indx - startIndex - 9);ऀऀ⼀⼀ ⼀⼀ 琀栀攀 氀椀渀欀 椀猀 琀栀攀 琀攀砀琀 戀攀琀眀攀攀渀 琀栀攀 ⌀䰀椀渀欀⸀⸀⸀ 愀渀搀 琀栀攀 渀攀砀琀 ✀尀尀✀⸀ഀ
|
||
// int iend = data.IndexOf("\\", indx);ऀऀ⼀⼀ 椀渀琀 戀椀渀搀砀 㴀 搀愀琀愀⸀䤀渀搀攀砀伀昀⠀∀⌀∀Ⰰ 椀渀搀砀⤀㬀ഀ
|
||
// vte.Link = data.Substring(bindx, iend - bindx);ऀऀ⼀⼀ 䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀⸀䄀搀搀⠀瘀琀攀⤀㬀ഀ
|
||
// // unfortunately, the rtf box may add the \protect0 \v0 in either orderऀऀ⼀⼀ ⼀⼀ 愀渀搀 眀椀琀栀 漀爀 眀椀琀栀漀甀琀 漀渀攀 漀爀 洀漀爀攀 猀瀀愀挀攀猀 戀攀琀眀攀攀渀 琀栀攀渀⸀ 吀栀攀 渀甀洀戀攀爀 漀昀 琀攀砀琀ഀ
|
||
// // characters = 11 for \protect0\v0 - find the number of spaces between themऀऀ⼀⼀ ⼀⼀ 椀昀 愀渀礀㼀ഀ
|
||
// int nsp = 0;ऀऀ⼀⼀ 昀漀爀 ⠀椀渀琀 挀 㴀 椀攀渀搀㬀 挀 㰀 椀攀渀搀 ⬀ 㬀 挀⬀⬀⤀ 椀昀 ⠀搀愀琀愀嬀挀崀 㴀㴀 ✀ ✀⤀ 渀猀瀀⬀⬀㬀ഀ
|
||
// return iend + 11 + nsp;ऀऀ⼀⼀紀ഀ
|
||
private int FindRtfChar(string text, int startIndex)ऀऀ笀ഀ
|
||
// look for the first 'rtf' token that represents either a link or symbol. Skipऀऀऀ⼀⼀ 漀瘀攀爀 愀渀礀 昀漀爀洀愀琀琀椀渀最 挀漀洀洀愀渀搀猀⸀⸀ഀ
|
||
bool done = false;ऀऀऀ椀渀琀 椀渀搀砀 㴀 猀琀愀爀琀䤀渀搀攀砀㬀ഀ
|
||
while (!done)ऀऀऀ笀ഀ
|
||
indx = text.IndexOf("\\", indx);ऀऀऀऀ椀昀 ⠀椀渀搀砀 㴀㴀 ⴀ⤀ 爀攀琀甀爀渀 椀渀搀砀㬀ഀ
|
||
if ((indx + 8) < text.Length && text.Substring(indx + 1, 7) == "protect") return indx;ऀऀऀऀ椀昀 ⠀琀攀砀琀⸀匀甀戀猀琀爀椀渀最⠀椀渀搀砀 ⬀ Ⰰ ⤀ 㴀㴀 ∀✀∀⤀ 爀攀琀甀爀渀 椀渀搀砀㬀ഀ
|
||
if (text.Substring(indx + 1, 1) == "u" && text.Substring(indx + 2, 1) != "l") return indx;ऀऀऀऀ椀渀搀砀 㴀 椀渀搀砀 ⬀ ㈀㬀 ⼀⼀ 最攀琀 瀀愀猀琀 尀尀 昀漀爀 渀攀砀琀 琀爀礀⸀ഀ
|
||
}ऀऀऀ爀攀琀甀爀渀 ⴀ㬀ഀ
|
||
ऀऀऀ⼀⼀椀渀琀 瀀爀椀渀搀砀 㴀 琀攀砀琀⸀䤀渀搀攀砀伀昀⠀∀尀尀瀀爀漀琀攀挀琀∀Ⰰ 猀琀愀爀琀䤀渀搀攀砀⤀㬀ഀ
|
||
//int symindx1 = text.IndexOf("\\'", startIndex);ऀऀऀ⼀⼀椀渀琀 猀礀洀椀渀搀砀㈀ 㴀 琀攀砀琀⸀䤀渀搀攀砀伀昀⠀∀尀尀甀∀Ⰰ 猀琀愀爀琀䤀渀搀攀砀⤀㬀ഀ
|
||
//// if a 'u' is found, it can be either unicode or underline, if it's underline,ऀऀऀ⼀⼀⼀⼀ 猀攀愀爀挀栀 琀栀攀 猀琀爀椀渀最 昀漀爀 ഀ
|
||
//if (symindx2 > -1)ऀऀऀ⼀⼀笀ഀ
|
||
// if (text[symindx2+2] == 'l') symindx2 = -1; // don't process underlinesऀऀऀ⼀⼀紀ഀ
|
||
//if (prindx == -1 && symindx1 == -1 && symindx2 == -1) return -1;ऀऀऀ⼀⼀椀昀 ⠀瀀爀椀渀搀砀 㴀㴀 ⴀ⤀ 瀀爀椀渀搀砀 㴀 琀攀砀琀⸀䰀攀渀最琀栀 ⬀ 㬀ഀ
|
||
//if (symindx1 == -1) symindx1 = text.Length + 1;ऀऀऀ⼀⼀椀昀 ⠀猀礀洀椀渀搀砀㈀ 㴀㴀 ⴀ⤀ 猀礀洀椀渀搀砀㈀ 㴀 琀攀砀琀⸀䰀攀渀最琀栀 ⬀ 㬀ഀ
|
||
ऀऀऀ⼀⼀⼀⼀ 圀栀椀挀栀 琀漀欀攀渀 栀愀猀 猀洀愀氀氀攀猀琀 渀甀洀戀攀爀Ⰰ 琀漀 搀攀琀攀爀洀椀渀攀 眀栀椀挀栀 椀琀攀洀 椀猀 渀攀砀琀ഀ
|
||
//// in the string. If it is a symbol - see if it has a font specifierऀऀऀ⼀⼀⼀⼀ 昀椀爀猀琀⸀ഀ
|
||
//int symindx = symindx1 < symindx2 ? symindx1 : symindx2;ऀऀऀ⼀⼀椀渀琀 猀洀愀氀氀攀猀琀 㴀 ⠀瀀爀椀渀搀砀 㰀 猀礀洀椀渀搀砀 㼀 瀀爀椀渀搀砀 㨀 猀礀洀椀渀搀砀⤀㬀ഀ
|
||
//return smallest;ऀऀ紀ഀ
|
||
private int GetFontTable(string rtf)ऀऀ笀ഀ
|
||
dicRtfFontTable = new Dictionary<int, string>();ऀऀऀ⼀⼀ 爀攀琀甀爀渀 甀渀椀挀漀搀攀 ⠀猀礀洀戀漀氀⤀ 昀漀渀琀 渀甀洀戀攀爀Ⰰ 椀昀 椀琀 攀砀椀猀琀猀Ⰰ 琀漀 攀砀瀀攀搀椀琀攀 昀椀渀搀椀渀最ഀ
|
||
// the font for symbols.ऀऀऀ椀渀琀 甀渀椀挀漀搀攀䘀漀渀琀 㴀 ⴀ㬀ഀ
|
||
int bindx = rtf.IndexOf(@"{\fonttbl");ऀऀऀ椀昀 ⠀戀椀渀搀砀 㰀 ⴀ⤀ 爀攀琀甀爀渀 ⴀ㬀ഀ
|
||
int eindx = rtf.IndexOf("}}", bindx);ऀऀऀ⼀⼀ 最攀琀 昀漀渀琀 琀愀戀氀攀 猀琀爀椀渀最 愀渀搀 琀栀攀渀 搀漀 爀攀最甀氀愀爀 攀砀瀀爀攀猀猀椀漀渀猀 琀漀 最攀琀 昀漀渀琀 渀甀洀戀攀爀 ഀ
|
||
// with font name.ऀऀऀ猀琀爀椀渀最 琀戀氀 㴀 爀琀昀⸀匀甀戀猀琀爀椀渀最⠀戀椀渀搀砀 ⬀ 㤀Ⰰ 攀椀渀搀砀 ⴀ 戀椀渀搀砀 ⴀ 㠀⤀㬀ഀ
|
||
tbl = tbl.Replace("{", "<");ऀऀऀ琀戀氀 㴀 琀戀氀⸀刀攀瀀氀愀挀攀⠀∀紀∀Ⰰ ∀㸀∀⤀㬀ഀ
|
||
string pat = @"(?:<\\f)([0-9]+)(?:[\S]+ )([\w ]+)";ऀऀऀ匀琀爀椀渀最䈀甀椀氀搀攀爀 猀戀 㴀 渀攀眀 匀琀爀椀渀最䈀甀椀氀搀攀爀⠀⤀㬀ഀ
|
||
foreach (Match m in Regex.Matches(tbl, pat))ऀऀऀ笀ഀ
|
||
int num = Convert.ToInt32(m.Result("${1}"));ऀऀऀऀ猀琀爀椀渀最 渀愀洀 㴀 洀⸀刀攀猀甀氀琀⠀∀␀笀㈀紀∀⤀㬀ഀ
|
||
dicRtfFontTable.Add(num, nam);ऀऀऀऀ椀昀 ⠀⠀甀渀椀挀漀搀攀䘀漀渀琀 㴀㴀 ⴀ⤀ ☀☀ ⠀渀愀洀 㴀㴀 ∀䄀爀椀愀氀 唀渀椀挀漀搀攀 䴀匀∀⤀⤀ 甀渀椀挀漀搀攀䘀漀渀琀 㴀 渀甀洀㬀ഀ
|
||
}ऀऀऀ爀攀琀甀爀渀 甀渀椀挀漀搀攀䘀漀渀琀㬀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 猀琀爀椀渀最 刀攀洀漀瘀攀刀琀昀匀琀礀氀攀猀⠀猀琀爀椀渀最 爀琀昀⤀ഀ
|
||
{ऀऀऀ猀琀爀椀渀最 爀攀琀瘀愀氀 㴀 爀琀昀㬀ഀ
|
||
// remove rtf commands for any styles that were added. Note that ifऀऀऀ⼀⼀ 琀栀攀 攀渀琀椀爀攀 椀琀攀洀 栀愀猀 愀 猀琀礀氀攀Ⰰ 愀渀搀 愀氀猀漀 挀漀渀琀愀椀渀猀 ✀瀀椀攀挀攀猀✀ 漀昀 琀攀砀琀 眀椀琀栀ഀ
|
||
// the same style, the underlying rtf box removes the embedded rtf commands,ऀऀऀ⼀⼀ 昀漀爀 攀砀愀洀瀀氀攀Ⰰ 椀昀 琀栀攀 攀渀琀椀爀攀 猀琀攀瀀 椀猀 戀漀氀搀攀搀Ⰰ 愀渀搀 ✀吀䠀䔀一✀ 栀愀猀 戀漀氀搀 漀渀⼀漀昀昀ഀ
|
||
// surrounding it, the rtf box removes the bold around the 'THEN'ऀऀऀ⼀⼀ 吀栀攀猀攀 爀攀洀漀瘀攀 琀栀攀 挀漀洀洀愀渀搀 眀椀琀栀 愀 昀漀氀氀漀眀椀渀最 猀瀀愀挀攀 漀爀 琀栀攀 挀漀洀洀愀渀搀 愀氀漀渀攀Ⰰഀ
|
||
// either case may exist, because if there are rtf commands following theऀऀऀ⼀⼀ 猀琀礀氀攀 挀漀洀洀愀渀搀Ⰰ 琀栀攀爀攀 眀椀氀氀 戀攀 渀漀 猀瀀愀挀攀 挀栀愀爀愀挀琀攀爀 昀漀氀氀漀眀椀渀最 琀栀攀 猀琀礀氀攀 挀漀洀洀愀渀搀⸀ഀ
|
||
if ((TextFont.Style & E_Style.Bold) > 0)ऀऀऀ笀ഀ
|
||
retval = Regex.Replace(retval, @"\\b0 ?", "");ऀऀऀऀ爀攀琀瘀愀氀 㴀 刀攀最攀砀⸀刀攀瀀氀愀挀攀⠀爀攀琀瘀愀氀Ⰰ 䀀∀尀尀戀 㼀∀Ⰰ∀∀⤀㬀ഀ
|
||
}ऀऀऀ椀昀 ⠀⠀吀攀砀琀䘀漀渀琀⸀匀琀礀氀攀 ☀ 䔀开匀琀礀氀攀⸀唀渀搀攀爀氀椀渀攀⤀ 㸀 ⤀ഀ
|
||
{ऀऀऀऀ爀攀琀瘀愀氀 㴀 刀攀最攀砀⸀刀攀瀀氀愀挀攀⠀爀攀琀瘀愀氀Ⰰ 䀀∀尀尀甀氀渀漀渀攀 㼀∀Ⰰ ∀∀⤀㬀ഀ
|
||
retval = Regex.Replace(retval, @"\\ul ?", "");ऀऀऀ紀ഀ
|
||
if ((TextFont.Style & E_Style.Italics) > 0)ऀऀऀ笀ഀ
|
||
retval = Regex.Replace(retval, @"\\i0 ?", "");ऀऀऀऀ爀攀琀瘀愀氀 㴀 刀攀最攀砀⸀刀攀瀀氀愀挀攀⠀爀攀琀瘀愀氀Ⰰ 䀀∀尀尀椀 㼀∀Ⰰ ∀∀⤀㬀ഀ
|
||
}ऀऀऀ爀攀琀甀爀渀 爀攀琀瘀愀氀㬀ഀ
|
||
}ऀऀ瀀甀戀氀椀挀 猀琀爀椀渀最 刀攀瀀氀愀挀攀刀吀䘀䌀氀愀甀猀攀⠀䴀愀琀挀栀 洀⤀ഀ
|
||
{ऀऀऀ猀眀椀琀挀栀 ⠀洀⸀嘀愀氀甀攀嬀崀⤀ഀ
|
||
{ऀऀऀऀ挀愀猀攀 ✀甀✀㨀ഀ
|
||
if (Regex.IsMatch(m.Value, @"\\u[0-9]+"))ऀऀऀऀऀऀ爀攀琀甀爀渀 洀⸀嘀愀氀甀攀㬀 ⼀⼀ 匀瀀攀挀椀愀氀 䌀栀愀爀挀愀琀攀爀猀ഀ
|
||
if (Regex.IsMatch(m.Value, @"\\ulnone"))ऀऀऀऀऀऀ爀攀琀甀爀渀 洀⸀嘀愀氀甀攀㬀ഀ
|
||
if (Regex.IsMatch(m.Value, @"\\ul.*"))ऀऀऀऀऀऀ爀攀琀甀爀渀 洀⸀嘀愀氀甀攀㬀 ⼀⼀ 唀渀搀攀爀氀椀渀攀ഀ
|
||
break;ऀऀऀऀ挀愀猀攀 ✀尀✀✀㨀 ⼀⼀ 匀瀀攀挀椀愀氀 䌀栀愀爀愀挀琀攀爀ഀ
|
||
return m.Value;ऀऀऀऀ挀愀猀攀 ✀戀✀㨀 ⼀⼀ 䈀漀氀搀ഀ
|
||
return m.Value;ऀऀऀऀ挀愀猀攀 ✀猀✀㨀ऀ⼀⼀ 猀甀戀 漀爀 猀甀瀀攀爀⸀⸀⸀⸀ഀ
|
||
if (m.Value == @"\sub") return m.Value;ऀऀऀऀऀ椀昀 ⠀洀⸀嘀愀氀甀攀 㴀㴀 䀀∀尀猀甀瀀攀爀∀⤀ 爀攀琀甀爀渀 洀⸀嘀愀氀甀攀㬀ഀ
|
||
break;ऀऀऀऀ挀愀猀攀 ✀渀✀㨀ऀ⼀⼀ 渀漀猀甀戀猀甀瀀攀爀⸀⸀⸀ഀ
|
||
if (m.Value == @"\nosupersub") return m.Value;ऀऀऀऀऀ戀爀攀愀欀㬀ഀ
|
||
case 'i': // Italicsऀऀऀऀऀ爀攀琀甀爀渀 洀⸀嘀愀氀甀攀㬀ഀ
|
||
case '{': // look for escape for curly braces:ऀऀऀऀऀ爀攀琀甀爀渀 洀⸀嘀愀氀甀攀㬀ഀ
|
||
case '}':ऀऀऀऀऀ爀攀琀甀爀渀 洀⸀嘀愀氀甀攀㬀ഀ
|
||
case 'v': // save link hidden infoऀऀऀऀऀ椀昀 ⠀洀⸀嘀愀氀甀攀 㴀㴀 䀀∀尀瘀∀⤀ 爀攀琀甀爀渀 洀⸀嘀愀氀甀攀㬀ऀ⼀⼀ 瀀愀爀琀 漀昀 氀椀渀欀ഀ
|
||
if (Regex.IsMatch(m.Value, @"\\v0"))ऀऀऀऀऀऀ爀攀琀甀爀渀 洀⸀嘀愀氀甀攀㬀 ⼀⼀ 栀椀搀搀攀渀 椀渀昀漀 漀昀昀ഀ
|
||
break;ऀऀऀऀ挀愀猀攀 ✀瀀✀㨀ഀ
|
||
if (m.Value == @"\par") return "\r\n";ऀऀऀऀऀ椀昀 ⠀洀⸀嘀愀氀甀攀 㴀㴀 䀀∀尀瀀爀漀琀攀挀琀∀⤀ഀ
|
||
return m.Value;ऀऀऀऀऀ椀昀 ⠀洀⸀嘀愀氀甀攀 㴀㴀 䀀∀尀瀀爀漀琀攀挀琀 ∀⤀ഀ
|
||
return m.Value;ऀऀऀऀऀ戀爀攀愀欀㬀ഀ
|
||
}ऀऀऀ爀攀琀甀爀渀 ∀∀㬀⼀⼀匀琀爀椀瀀 䄀氀氀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 猀琀爀椀渀最 匀琀爀椀瀀刀琀昀䌀漀洀洀愀渀搀猀⠀猀琀爀椀渀最 爀琀昀⤀ഀ
|
||
{ऀऀऀ⼀⼀ 爀攀瀀氀愀挀攀 尀笀 ☀ 尀紀 眀椀琀栀 ⠀℀嬀 ☀ ⠀℀崀 爀攀猀瀀攀挀琀椀瘀攀氀礀 愀渀搀 琀栀攀渀 爀攀搀漀 愀琀 攀渀搀⸀ 吀栀攀 挀甀爀氀礀 戀爀愀挀攀猀ഀ
|
||
// are rtf so were getting removed and/or not handled correctly.ऀऀऀ猀琀爀椀渀最 爀攀琀瘀愀氀 㴀 爀琀昀⸀刀攀瀀氀愀挀攀⠀䀀∀尀笀∀Ⰰ 䀀∀⠀℀嬀∀⤀㬀ഀ
|
||
retval = retval.Replace(@"\}", @"(!]");ऀऀऀ爀攀琀瘀愀氀 㴀 刀攀最攀砀⸀刀攀瀀氀愀挀攀⠀爀攀琀瘀愀氀Ⰰ 䀀∀嬀尀爀尀渀崀∀Ⰰ ∀∀Ⰰ 刀攀最攀砀伀瀀琀椀漀渀猀⸀匀椀渀最氀攀氀椀渀攀⤀㬀 ⼀⼀ 匀琀爀椀瀀 䌀愀爀爀椀愀最攀 刀攀琀甀爀渀猀 愀渀搀 一攀眀氀椀渀攀猀ഀ
|
||
retval = Regex.Replace(retval, @"^\{(.*)\}$", "$1", RegexOptions.Singleline); // Strip Opening and Closing Bracesऀऀऀ爀攀琀瘀愀氀 㴀 刀攀最攀砀⸀刀攀瀀氀愀挀攀⠀爀攀琀瘀愀氀Ⰰ 䀀∀尀笀嬀帀笀崀⨀㼀尀紀∀Ⰰ ∀∀Ⰰ 刀攀最攀砀伀瀀琀椀漀渀猀⸀匀椀渀最氀攀氀椀渀攀⤀㬀 ⼀⼀ 匀琀爀椀瀀 䌀氀愀甀猀攀猀 ⴀ 爀攀洀漀瘀攀 愀渀礀琀栀椀渀最 昀爀漀洀 挀甀爀氀礀 戀爀愀挀攀猀ഀ
|
||
retval = Regex.Replace(retval, @"\{[^{]*?\}", "", RegexOptions.Singleline); // Strip Clauses - remove anything from curly bracesऀऀऀ爀攀琀瘀愀氀 㴀 刀攀最攀砀⸀刀攀瀀氀愀挀攀⠀爀攀琀瘀愀氀Ⰰ 䀀∀尀尀嬀帀 尀尀㼀崀⬀∀Ⰰ 渀攀眀 䴀愀琀挀栀䔀瘀愀氀甀愀琀漀爀⠀刀攀瀀氀愀挀攀刀吀䘀䌀氀愀甀猀攀⤀⤀㬀 ⼀⼀ 琀愀欀攀 戀愀挀欀猀氀愀猀栀 砀礀稀 愀渀搀 攀瘀愀氀甀愀琀攀猀 琀栀攀洀ഀ
|
||
// remove a space if there is one as the first character..ऀऀऀ椀昀 ⠀爀攀琀瘀愀氀嬀 崀㴀㴀✀ ✀⤀爀攀琀瘀愀氀 㴀 爀攀琀瘀愀氀⸀刀攀洀漀瘀攀⠀ Ⰰ ⤀㬀ഀ
|
||
// remove \r\n at end of string - this was added with the \par at the end of string by the rtf boxऀऀऀ椀昀 ⠀爀攀琀瘀愀氀⸀匀甀戀猀琀爀椀渀最⠀爀攀琀瘀愀氀⸀䰀攀渀最琀栀 ⴀ ㈀Ⰰ ㈀⤀ 㴀㴀 ∀尀爀尀渀∀⤀ 爀攀琀瘀愀氀 㴀 爀攀琀瘀愀氀⸀刀攀洀漀瘀攀⠀爀攀琀瘀愀氀⸀䰀攀渀最琀栀 ⴀ ㈀Ⰰ ㈀⤀㬀ഀ
|
||
retval = RemoveRtfStyles(retval);ऀऀऀ爀攀琀瘀愀氀 㴀 爀攀琀瘀愀氀⸀刀攀瀀氀愀挀攀⠀䀀∀⠀℀嬀∀Ⰰ 䀀∀尀笀∀⤀㬀ഀ
|
||
retval = retval.Replace(@"(!]", @"\}");ऀऀऀ爀攀琀甀爀渀 爀攀琀瘀愀氀㬀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 猀琀爀椀渀最 吀漀䐀愀琀愀开刀伀⠀搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀 瘀琀攀⤀ഀ
|
||
{ऀऀऀ⼀⼀ 最攀琀 瀀愀猀琀 琀栀攀 ⌀䰀椀渀欀㨀刀攀昀攀爀攀渀挀攀搀伀戀樀攀挀琀 瀀愀爀琀 漀昀 琀栀攀 氀椀渀欀⸀ഀ
|
||
return String.Format("\x15ReferencedObject RO\\v0 {0}\\v #{1}\\v0", vte.Text, vte.Link.Substring(23, vte.Link.Length-23));ऀऀ紀ഀ
|
||
private string ToData_Trans(displayLinkElement vte)ऀऀ笀ഀ
|
||
char trchar = vte.Type == E_TextElementType.Transition ? '\x252C' : '\x2566';ऀऀऀ⼀⼀ 搀攀瀀攀渀搀椀渀最 漀渀 琀礀瀀攀Ⰰ 最攀琀 瀀愀猀琀 琀栀攀 ⌀䰀椀渀欀㨀吀爀愀渀猀椀琀椀漀渀㨀 漀爀 ⌀䰀椀渀欀㨀吀爀愀渀猀椀琀椀漀渀刀愀渀最攀㨀 瀀愀爀琀ഀ
|
||
// of text.ऀऀऀ椀渀琀 椀渀搀砀 㴀 瘀琀攀⸀吀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀吀爀愀渀猀椀琀椀漀渀 㼀 㠀 㨀 ㈀㌀㬀ഀ
|
||
return String.Format("{0}\\v TRAN\\v0 {1}\\v {2}\\v0", trchar, vte.Text, vte.Link.Substring(indx, vte.Link.Length-indx));ऀऀ紀ഀ
|
||
#endregionऀऀ⌀爀攀最椀漀渀 匀琀礀氀攀䐀愀琀愀ഀ
|
||
private VE_Font GetItemFont()ऀऀ笀ഀ
|
||
VE_Font font = null;ऀऀऀ䘀漀爀洀愀琀䤀渀昀漀 昀漀爀洀愀琀 㴀 开䴀礀䤀琀攀洀䤀渀昀漀⸀䄀挀琀椀瘀攀䘀漀爀洀愀琀㬀ഀ
|
||
int type = (int)_MyItemInfo.MyContent.Type;ऀऀऀ猀眀椀琀挀栀 ⠀琀礀瀀攀⼀ ⤀ഀ
|
||
{ऀऀऀऀ挀愀猀攀 㨀ऀ⼀⼀ 瀀爀漀挀攀搀甀爀攀ഀ
|
||
font = format.PlantFormat.FormatData.Font;ऀऀऀऀऀ戀爀攀愀欀㬀ഀ
|
||
case 1: // sectionऀऀऀऀऀ昀漀渀琀 㴀 昀漀爀洀愀琀⸀倀氀愀渀琀䘀漀爀洀愀琀⸀䘀漀爀洀愀琀䐀愀琀愀⸀匀攀挀琀䐀愀琀愀⸀匀攀挀琀椀漀渀䠀攀愀搀攀爀⸀䘀漀渀琀㬀ഀ
|
||
break;ऀऀऀऀ挀愀猀攀 ㈀㨀 ⼀⼀ 猀琀攀瀀 琀礀瀀攀猀ഀ
|
||
int typindx = type - 20000; // what to do for other types rather than stepsऀऀऀऀऀ昀漀渀琀 㴀 昀漀爀洀愀琀⸀倀氀愀渀琀䘀漀爀洀愀琀⸀䘀漀爀洀愀琀䐀愀琀愀⸀匀琀攀瀀䐀愀琀愀䰀椀猀琀嬀琀礀瀀椀渀搀砀崀⸀䘀漀渀琀㬀ഀ
|
||
break;ऀऀऀ紀ഀ
|
||
TextFont = font;ऀऀऀ爀攀琀甀爀渀 昀漀渀琀㬀ഀ
|
||
}ऀऀ⌀攀渀搀爀攀最椀漀渀ഀ
|
||
#region DoListElementsऀऀ瀀爀椀瘀愀琀攀 椀渀琀 䘀椀渀搀吀漀欀攀渀䌀栀愀爀⠀猀琀爀椀渀最 琀砀琀Ⰰ 椀渀琀 猀琀愀爀琀䤀渀搀攀砀⤀ഀ
|
||
{ऀऀऀ⼀⼀ 琀漀欀攀渀猀 愀爀攀 爀漀Ⰰ 琀爀愀渀猀椀琀椀漀渀猀 愀渀搀 瀀漀猀猀椀戀氀攀 猀礀洀戀漀氀ഀ
|
||
char[] tok = { '\x15', '\x252C', '\x2566', '\\' };ऀऀऀ戀漀漀氀 搀漀渀攀 㴀 昀愀氀猀攀㬀ഀ
|
||
// If there is only an rtf token from the indexed position on, don't return theऀऀऀ⼀⼀ 䤀渀搀攀砀伀昀䄀渀礀 椀渀搀攀砀 瘀愀氀甀攀Ⰰ 戀攀挀愀甀猀攀 椀琀 眀椀氀氀 戀礀 漀渀攀 挀栀愀爀愀挀琀攀爀 瀀愀猀琀 琀栀攀 ✀尀✀ 愀渀搀 琀栀爀漀眀ഀ
|
||
// of the return value of where in the string the text should be saved. For exampleऀऀऀ⼀⼀ 昀漀爀 琀栀攀 猀琀爀椀渀最 ✀尀戀 琀攀砀琀 尀瘀 猀漀洀攀瘀愀氀甀攀 尀瘀 尀戀 ✀Ⰰ 琀栀攀 昀椀爀猀琀 琀椀洀攀 琀栀爀漀甀最栀 琀栀攀 眀栀椀氀攀ഀ
|
||
// loop has the index at the '\b' char of the b0. ऀऀऀ⼀⼀椀渀琀 猀愀瘀猀琀愀爀琀䤀渀搀攀砀 㴀 猀琀愀爀琀䤀渀搀攀砀㬀ഀ
|
||
while (!done)ऀऀऀ笀ഀ
|
||
int indx = txt.IndexOfAny(tok, startIndex);ऀऀऀऀ椀昀 ⠀椀渀搀砀 㰀 ⤀ 爀攀琀甀爀渀 椀渀搀砀㬀ഀ
|
||
if (txt[indx] != '\\') return indx;ऀऀऀऀ⼀⼀ 猀攀攀 椀昀 猀礀洀戀漀氀 ⠀戀甀琀 渀漀琀 甀渀搀攀爀氀椀渀攀⤀ 漀爀 愀渀漀琀栀攀爀 爀琀昀 挀漀洀洀愀渀搀㨀 栀愀猀 愀 ✀甀✀ ഀ
|
||
// followed by a non-underline or single quote, and if so, return it. ऀऀऀऀ⼀⼀ 伀琀栀攀爀眀椀猀攀Ⰰ 最攀琀 渀攀砀琀 椀渀搀攀砀Ⰰ 洀甀猀琀 栀愀瘀攀 戀攀攀渀 愀 猀氀愀猀栀 漀爀 漀琀栀攀爀 爀琀昀 挀漀洀洀愀渀搀⸀ഀ
|
||
if (((txt[indx + 1] == 'u' && txt[indx + 2] != 'l')) || (txt[indx + 1] == '\'')) return indx;ऀऀऀऀ猀琀愀爀琀䤀渀搀攀砀㴀椀渀搀砀⬀㬀ഀ
|
||
}ऀऀऀ爀攀琀甀爀渀 ⴀ㬀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 椀渀琀 䐀漀吀攀砀琀䔀氀攀洀攀渀琀⠀猀琀爀椀渀最 琀攀砀琀Ⰰ 椀渀琀 猀琀愀爀琀䤀渀搀攀砀Ⰰ 椀渀琀 椀渀搀攀砀⤀ഀ
|
||
{ऀऀऀ搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀 瘀琀攀 㴀 渀攀眀 搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀⠀⤀㬀ഀ
|
||
vte.Type = E_TextElementType.Text;ऀऀऀ椀渀琀 氀攀渀 㴀 ⠀椀渀搀攀砀 㴀㴀 ⴀ⤀ 㼀 琀攀砀琀⸀䰀攀渀最琀栀 ⴀ 猀琀愀爀琀䤀渀搀攀砀 㨀 椀渀搀攀砀 ⴀ 猀琀愀爀琀䤀渀搀攀砀㬀ഀ
|
||
vte.Text = text.Substring(startIndex, len);ऀऀऀ䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀⸀䄀搀搀⠀瘀琀攀⤀㬀ഀ
|
||
return index+1;ऀऀ紀ഀ
|
||
private string CreateLink(E_TextElementType type, string linktxt)ऀऀ笀ഀ
|
||
string retlink = "";ऀऀऀ椀昀 ⠀琀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀刀攀昀攀爀攀渀挀攀搀伀戀樀攀挀琀⤀ഀ
|
||
retlink = "#Link:ReferencedObject:" + linktxt;ऀऀऀ攀氀猀攀 椀昀 ⠀琀礀瀀攀 㴀㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀吀爀愀渀猀椀琀椀漀渀⤀ഀ
|
||
retlink = "#Link:Transition:" + linktxt;ऀऀऀ攀氀猀攀ഀ
|
||
retlink = "#Link:TransitionRange:" + linktxt;ऀऀഀ
|
||
return retlink;ऀऀ紀ഀ
|
||
private int DoRO(string text, int index)ऀऀ笀ഀ
|
||
displayLinkElement vte = new displayLinkElement();ऀऀऀ瘀琀攀⸀吀礀瀀攀 㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀刀攀昀攀爀攀渀挀攀搀伀戀樀攀挀琀㬀ഀ
|
||
int iend = text.IndexOf(@"\v", index);ഀ
|
||
vte.Text = text.Substring(index + 1, iend - index - 1);ऀऀऀ椀渀琀 椀猀琀愀爀琀 㴀 琀攀砀琀⸀䤀渀搀攀砀伀昀⠀∀⌀∀Ⰰ 椀渀搀攀砀⤀㬀ഀ
|
||
iend = text.IndexOf(@"\v0", istart);ऀऀऀ瘀琀攀⸀䰀椀渀欀 㴀 琀攀砀琀⸀匀甀戀猀琀爀椀渀最⠀椀猀琀愀爀琀Ⰰ 椀攀渀搀 ⴀ 椀猀琀愀爀琀⤀㬀ഀ
|
||
DisplayTextElementList.Add(vte);ऀऀऀ爀攀琀甀爀渀 椀攀渀搀 ⬀ ㌀㬀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 猀琀爀椀渀最 䘀椀砀吀爀愀渀猀椀琀椀漀渀⠀猀琀爀椀渀最 氀椀渀欀Ⰰ 猀琀爀椀渀最 琀攀砀琀⤀ഀ
|
||
{ऀऀऀ椀渀琀 琀爀愀渀猀椀琀椀漀渀䤀䐀 㴀 䌀漀渀瘀攀爀琀⸀吀漀䤀渀琀㌀㈀⠀氀椀渀欀⸀匀瀀氀椀琀⠀∀ ∀⸀吀漀䌀栀愀爀䄀爀爀愀礀⠀⤀⤀嬀崀⤀㬀ഀ
|
||
// Find the transitionऀऀऀ昀漀爀攀愀挀栀 ⠀吀爀愀渀猀椀琀椀漀渀䤀渀昀漀 琀椀 椀渀 开䴀礀䤀琀攀洀䤀渀昀漀⸀䴀礀䌀漀渀琀攀渀琀⸀䌀漀渀琀攀渀琀吀爀愀渀猀椀琀椀漀渀猀⤀ഀ
|
||
{ऀऀऀऀ椀昀 ⠀琀椀⸀吀爀愀渀猀椀琀椀漀渀䤀䐀 㴀㴀 琀爀愀渀猀椀琀椀漀渀䤀䐀⤀ഀ
|
||
{ऀऀऀऀऀ⼀⼀猀琀爀椀渀最 瀀愀琀栀 㴀 琀椀⸀倀愀琀栀吀漀⸀刀攀瀀氀愀挀攀⠀∀ 匀攀挀琀椀漀渀 倀刀伀䌀䔀䐀唀刀䔀 匀吀䔀倀匀 ∀Ⰰ ∀Ⰰ ∀⤀㬀ഀ
|
||
//path = path.Replace(" Section PROCEDURE STEPS", "");ऀऀऀऀऀ猀琀爀椀渀最 瀀愀琀栀 㴀 琀椀⸀刀攀猀漀氀瘀攀倀愀琀栀吀漀⠀开䴀礀䘀漀爀洀愀琀Ⰰ 开䴀礀䤀琀攀洀䤀渀昀漀Ⰰ 䤀琀攀洀䤀渀昀漀⸀䜀攀琀⠀琀椀⸀吀漀䤀䐀⤀Ⰰ 琀椀⸀刀愀渀最攀䤀䐀㴀㴀 㼀渀甀氀氀㨀䤀琀攀洀䤀渀昀漀⸀䜀攀琀⠀琀椀⸀刀愀渀最攀䤀䐀⤀⤀㬀ഀ
|
||
return path;ऀऀऀऀ紀ഀ
|
||
}ऀऀऀ爀攀琀甀爀渀 琀攀砀琀㬀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 椀渀琀 䐀漀吀爀愀渀⠀猀琀爀椀渀最 琀攀砀琀Ⰰ椀渀琀 椀渀搀攀砀⤀ഀ
|
||
{ऀऀऀ搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀 瘀琀攀 㴀 渀攀眀 搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀⠀⤀㬀ഀ
|
||
if (text[index]=='\x252C') vte.Type = E_TextElementType.Transition;ऀऀऀ攀氀猀攀 瘀琀攀⸀吀礀瀀攀 㴀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀⸀吀爀愀渀猀椀琀椀漀渀刀愀渀最攀㬀ऀऀ⼀⼀ ✀尀砀㈀㔀㘀㘀✀尀ഀ
|
||
int iend = text.IndexOf(@"\v",index);ऀऀऀ瘀琀攀⸀吀攀砀琀 㴀 琀攀砀琀⸀匀甀戀猀琀爀椀渀最⠀椀渀搀攀砀 ⬀ Ⰰ 椀攀渀搀 ⴀ 椀渀搀攀砀 ⴀ ⤀㬀ഀ
|
||
int istart = text.IndexOf("#", index);ऀऀऀ椀攀渀搀 㴀 琀攀砀琀⸀䤀渀搀攀砀伀昀⠀䀀∀尀瘀 ∀Ⰰ 椀猀琀愀爀琀⤀㬀ഀ
|
||
vte.Link = text.Substring(istart, iend-istart);ऀऀऀ瘀琀攀⸀吀攀砀琀 㴀 䘀椀砀吀爀愀渀猀椀琀椀漀渀⠀瘀琀攀⸀䰀椀渀欀Ⰰ 瘀琀攀⸀吀攀砀琀⤀㬀 ⼀⼀ 吀伀䐀伀㨀 吀爀愀渀猀椀琀椀漀渀 琀攀砀琀 爀攀猀漀氀甀琀椀漀渀㼀ഀ
|
||
DisplayTextElementList.Add(vte);ऀऀऀ爀攀琀甀爀渀 椀攀渀搀 ⬀ ㌀㬀ഀ
|
||
}ऀऀ瀀爀椀瘀愀琀攀 椀渀琀 䐀漀匀礀洀戀漀氀⠀猀琀爀椀渀最 琀攀砀琀Ⰰ 椀渀琀 猀琀愀爀琀䤀渀搀攀砀Ⰰ 椀渀琀 椀渀搀攀砀⤀ഀ
|
||
{ऀऀऀ搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀 瘀琀攀 㴀 渀攀眀 搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀⠀⤀㬀ഀ
|
||
vte.Type = E_TextElementType.Symbol;ऀऀऀ⼀⼀ 猀礀洀戀漀氀猀 愀爀攀 琀栀攀 甀渀椀挀漀搀攀⼀爀琀昀 挀漀洀洀愀渀搀⸀ 䄀 猀礀洀戀漀氀 挀愀渀 戀攀 爀攀瀀爀攀猀攀渀琀攀搀 戀礀 尀✀砀礀 漀爀 ഀ
|
||
// in the text from the database \uxyz?. If the \'xy is used the length of the ऀऀऀ⼀⼀ 猀礀洀戀漀氀 渀甀洀戀攀爀 眀椀氀氀 愀氀眀愀礀猀 戀攀 琀眀漀Ⰰ 漀琀栀攀爀眀椀猀攀 昀椀渀搀 琀栀攀 椀渀搀攀砀 漀昀 琀栀攀 ✀㼀✀ 琀漀 ഀ
|
||
// find the end.ऀऀऀ椀渀琀 攀渀搀椀渀搀砀 㴀 ⴀ㬀ഀ
|
||
if (text[index + 1] == '\'') endindx = index + 3;ऀऀऀ攀氀猀攀 攀渀搀椀渀搀砀 㴀 琀攀砀琀⸀䤀渀搀攀砀伀昀⠀∀㼀∀Ⰰ 椀渀搀攀砀⤀㬀ഀ
|
||
vte.Text = text.Substring(index, endindx - index + 1);ऀऀऀ䐀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䰀椀猀琀⸀䄀搀搀⠀瘀琀攀⤀㬀ഀ
|
||
// return the position just past the symbol.ऀऀऀ爀攀琀甀爀渀 攀渀搀椀渀搀砀⬀㬀ഀ
|
||
}ऀऀ⌀攀渀搀爀攀最椀漀渀ഀ
|
||
#region ReplaceWordsऀऀ瀀爀椀瘀愀琀攀 刀攀瀀氀愀挀攀匀琀爀 开爀猀㬀ഀ
|
||
private string ReplaceIt(Match m)ऀऀ笀ഀ
|
||
string s = m.ToString();ऀऀऀ猀琀爀椀渀最 琀 㴀 猀⸀刀攀瀀氀愀挀攀⠀开爀猀⸀刀攀瀀氀愀挀攀圀漀爀搀Ⰰ 开爀猀⸀刀攀瀀氀愀挀攀圀椀琀栀⤀㬀ഀ
|
||
return m.ToString().Replace(_rs.ReplaceWord, _rs.ReplaceWith);ऀऀ紀ഀ
|
||
private string DoReplaceWords(string Text)ऀऀ笀ഀ
|
||
ReplaceStrList rsl = _MyFormat.PlantFormat.FormatData.SectData.ReplaceStrList;ऀऀऀ昀漀爀攀愀挀栀 ⠀刀攀瀀氀愀挀攀匀琀爀 爀猀 椀渀 爀猀氀⤀ഀ
|
||
{ऀऀऀऀ椀昀 ⠀开䴀礀䤀琀攀洀䤀渀昀漀⸀䴀礀䌀漀渀琀攀渀琀⸀吀礀瀀攀 㰀 ㈀ ⤀ 爀攀琀甀爀渀 吀攀砀琀㬀 ⼀⼀ 昀漀爀 渀漀眀 漀渀氀礀 爀攀瀀氀愀挀攀 椀渀 猀琀攀瀀猀⸀ഀ
|
||
bool replaceit = false;ഀ
|
||
// note that the order of this check is important. Check in this order...ऀऀऀऀ⼀⼀ 戀愀挀欀最爀漀甀渀搀 栀攀爀攀ഀ
|
||
if (_MyItemInfo.IsHigh && (rs.Flag & E_ReplaceFlags.High)>0) replaceit = true;ऀऀऀऀ攀氀猀攀 椀昀 ⠀⠀开䴀礀䤀琀攀洀䤀渀昀漀⸀䤀猀吀愀戀氀攀 簀簀 开䴀礀䤀琀攀洀䤀渀昀漀⸀䤀猀䘀椀最甀爀攀⤀ ☀☀ ⠀爀猀⸀䘀氀愀最 ☀ 䔀开刀攀瀀氀愀挀攀䘀氀愀最猀⸀吀愀戀氀攀⤀ 㸀 ⤀ 爀攀瀀氀愀挀攀椀琀 㴀 琀爀甀攀㬀ഀ
|
||
else if (_MyItemInfo.IsInRNO && (rs.Flag & E_ReplaceFlags.RNO) > 0) replaceit = true;ऀऀऀऀ攀氀猀攀 椀昀 ⠀开䴀礀䤀琀攀洀䤀渀昀漀⸀䤀猀䌀愀甀琀椀漀渀 ☀☀ ⠀爀猀⸀䘀氀愀最 ☀ 䔀开刀攀瀀氀愀挀攀䘀氀愀最猀⸀䌀愀甀琀椀漀渀⤀ 㸀 ⤀ 爀攀瀀氀愀挀攀椀琀 㴀 琀爀甀攀㬀ഀ
|
||
else if (_MyItemInfo.IsNote && (rs.Flag & E_ReplaceFlags.Note) > 0) replaceit = true;ऀऀऀऀ攀氀猀攀 椀昀 ⠀开䴀礀䤀琀攀洀䤀渀昀漀⸀䤀猀䤀渀䘀椀爀猀琀䰀攀瘀攀氀匀甀戀匀琀攀瀀 ☀☀ ⠀爀猀⸀䘀氀愀最 ☀ 䔀开刀攀瀀氀愀挀攀䘀氀愀最猀⸀匀甀戀猀琀攀瀀⤀ 㸀 ⤀ 爀攀瀀氀愀挀攀椀琀 㴀 琀爀甀攀㬀ഀ
|
||
else if (_MyItemInfo.IsAccPages & (rs.Flag & E_ReplaceFlags.Attach) > 0) replaceit = true;ഀ
|
||
if (replaceit)ऀऀऀऀ笀ഀ
|
||
// CASEINSENS: Do ReplaceWords for all words that match, regardless of case, and replace ऀऀऀऀऀ⼀⼀ 眀椀琀栀 琀栀攀 刀攀瀀氀愀挀攀圀椀琀栀 猀琀爀椀渀最 愀猀 椀猀ഀ
|
||
if ((rs.Flag & E_ReplaceFlags.CaseInsens) > 0)ऀऀऀऀऀ笀ഀ
|
||
string res = "";ऀऀऀऀऀऀ猀琀爀椀渀最 昀漀爀琀攀猀琀 㴀 吀攀砀琀⸀吀漀唀瀀瀀攀爀⠀⤀㬀ഀ
|
||
string pat = @"(?<=\W|^)" + rs.ReplaceWord.ToUpper() + @"(?=\W|$)";ऀऀऀऀऀऀ椀渀琀 挀瀀椀渀搀砀 㴀 㬀ഀ
|
||
foreach (Match m in Regex.Matches(fortest, pat))ऀऀऀऀऀऀ笀ഀ
|
||
res += Text.Substring(cpindx, m.Index-cpindx);ऀऀऀऀऀऀऀ挀瀀椀渀搀砀 ⬀㴀 ⠀洀⸀䤀渀搀攀砀 ⴀ 挀瀀椀渀搀砀⤀㬀ഀ
|
||
res += rs.ReplaceWith;ऀऀऀऀऀऀऀ挀瀀椀渀搀砀 ⬀㴀 爀猀⸀刀攀瀀氀愀挀攀圀漀爀搀⸀䰀攀渀最琀栀㬀ഀ
|
||
}ऀऀऀऀऀऀ椀昀 ⠀挀瀀椀渀搀砀 㰀 吀攀砀琀⸀䰀攀渀最琀栀⤀ 爀攀猀 ⬀㴀 吀攀砀琀⸀匀甀戀猀琀爀椀渀最⠀挀瀀椀渀搀砀Ⰰ 吀攀砀琀⸀䰀攀渀最琀栀 ⴀ 挀瀀椀渀搀砀⤀㬀ഀ
|
||
Text = res;ऀऀऀऀऀ紀ഀ
|
||
// CASEINSENSALL: Do ReplaceWords for all words that match the ReplaceWord, regardless of caseऀऀऀऀऀ攀氀猀攀 椀昀 ⠀⠀爀猀⸀䘀氀愀最 ☀ 䔀开刀攀瀀氀愀挀攀䘀氀愀最猀⸀䌀愀猀攀䤀渀猀攀渀猀䄀氀氀⤀ 㸀 ⤀ഀ
|
||
{ऀऀऀऀऀऀ⼀⼀ 渀漀琀 椀渀 栀氀瀀ഀ
|
||
}ऀऀऀऀऀ⼀⼀ 䌀䄀匀䔀䤀一匀䔀一匀䘀䤀刀匀吀㨀ऀ䐀漀 刀攀瀀氀愀挀攀圀漀爀搀猀 昀漀爀 愀氀氀 眀漀爀搀猀 琀栀愀琀 攀砀愀挀琀氀礀 洀愀琀挀栀 琀栀攀 刀攀瀀氀愀挀攀圀漀爀搀Ⰰ ഀ
|
||
// except the case where the first character may be differentऀऀऀऀऀ攀氀猀攀 椀昀 ⠀⠀爀猀⸀䘀氀愀最 ☀ 䔀开刀攀瀀氀愀挀攀䘀氀愀最猀⸀䌀愀猀攀䤀渀猀攀渀猀䘀椀爀猀琀⤀ 㸀 ⤀ഀ
|
||
{ऀऀऀऀऀऀ⼀⼀ 渀漀琀 椀渀 栀氀瀀ഀ
|
||
}ऀऀऀऀऀ攀氀猀攀ഀ
|
||
{ऀऀऀऀऀऀ猀琀爀椀渀最 瀀愀琀 㴀 䀀∀⠀㼀㰀㴀尀圀簀帀⤀∀ ⬀ 爀猀⸀刀攀瀀氀愀挀攀圀漀爀搀 ⬀ 䀀∀⠀㼀㴀尀圀簀␀⤀∀㬀ഀ
|
||
Text = Regex.Replace(Text, pat, rs.ReplaceWith);ऀऀऀऀऀ紀ഀ
|
||
ऀऀऀऀ紀ഀ
|
||
}ऀऀऀ爀攀琀甀爀渀 吀攀砀琀㬀ഀ
|
||
}ऀऀ⌀攀渀搀爀攀最椀漀渀ഀ
|
||
}ऀ⌀爀攀最椀漀渀 搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀䌀氀愀猀猀ഀ
|
||
public enum E_TextElementType : uintऀ笀ഀ
|
||
Text = 0,ऀऀ吀爀愀渀猀椀琀椀漀渀 㴀 Ⰰഀ
|
||
TransitionRange = 2,ऀऀ刀攀昀攀爀攀渀挀攀搀伀戀樀攀挀琀 㴀 ㌀Ⰰഀ
|
||
Symbol = 4ऀ紀㬀ഀ
|
||
public class displayTextElementऀ笀ഀ
|
||
private E_TextElementType _Type;ऀऀ瀀甀戀氀椀挀 䔀开吀攀砀琀䔀氀攀洀攀渀琀吀礀瀀攀 吀礀瀀攀ഀ
|
||
{ऀऀऀ最攀琀 笀 爀攀琀甀爀渀 开吀礀瀀攀㬀 紀ഀ
|
||
set { _Type = value; }ऀऀ紀ഀ
|
||
private string _Text;ऀऀ瀀甀戀氀椀挀 猀琀爀椀渀最 吀攀砀琀ഀ
|
||
{ऀऀऀ最攀琀 笀 爀攀琀甀爀渀 开吀攀砀琀㬀 紀ഀ
|
||
set { _Text = value; }ऀऀ紀ഀ
|
||
}ऀ瀀甀戀氀椀挀 挀氀愀猀猀 搀椀猀瀀氀愀礀䰀椀渀欀䔀氀攀洀攀渀琀 㨀 搀椀猀瀀氀愀礀吀攀砀琀䔀氀攀洀攀渀琀ഀ
|
||
{ऀऀ瀀爀椀瘀愀琀攀 猀琀爀椀渀最 开䰀椀渀欀㬀ഀ
|
||
public string Linkऀऀ笀ഀ
|
||
get { return _Link; }ऀऀऀ猀攀琀 笀 开䰀椀渀欀 㴀 瘀愀氀甀攀㬀 紀ഀ
|
||
}ऀ紀ഀ
|
||
#endregionऀഀ
|
||
}<EFBFBD> |