/// <summary>
/// 获取rtf文本的颜色列表
/// </summary>
/// <returns></returns>
/// 创建时间： 2023-02-18 最后一次修改时间：2023-02-18 (已测试）
_DList<_Color> _Rtf::GetColorList() const
{
_DList<_Color> lc;
//{\rtf1\ansi\ansicpg936\deff0\nouicompat\deflang1033\deflangfe2052{\fonttbl{\f0\fnil\fcharset134 \'ce\'a2\'c8\'ed\'d1\'c5\'ba\'da;}}
//{\colortbl; \red254\green155\blue0; \red204\green255\blue204; \red0\green255\blue1; }
int i = _text.IndexOf("{\\colortbl"); //{\colortbl ;\red255\green254\blue1;}
if (i != -1)
{
int n = _text.IndexOfRightPairChar(i, '{', '}');
if (n != -1)
{
_StrA s = _text.SubStr(i, n - i + 1);
_StrListA slTemp(s, ";", true);
if (slTemp.Count > 1)
{
auto dn = slTemp.First()->Next;
while (dn != null)
{
_StrListA slColor(dn->Data, "\\", true);
if (slColor.Count == 3)
{
_StrA sNumber = slColor[0].GetAllArabicDigit();
int r = _Math::StrToInt_t<char>(sNumber);
sNumber = slColor[1].GetAllArabicDigit();
int g = _Math::StrToInt_t<char>(sNumber);
sNumber = slColor[2].GetAllArabicDigit();
int b = _Math::StrToInt_t<char>(sNumber);
lc.Add(_Color(r, g, b));
//d.PrintError(_geti(r) + _geti(g) + _geti(b));
}
dn = dn->Next;
}
}
}
}
return lc;
}
/// <summary>
/// 清除rtf文本的背景颜色
/// </summary>
/// <returns></returns>
/// 创建时间： 2023-02-21 最后一次修改时间：2023-02-21 (已测试）
_StrA& _Rtf::ClearTextBackColor()
{
/*
{\rtf1\ansi\ansicpg936\deff0\nouicompat\deflang1033\deflangfe2052{\fonttbl{\f0\fnil\fcharset134 \'ce\'a2\'c8\'ed\'d1\'c5\'ba\'da;}}
{\colortbl ;\red254\green155\blue0;}
{\*\generator Riched20 10.0.17763}\viewkind4\uc1
\pard\f0\fs20\lang2052 \highlight1 Color\highlight0\par
}
*/
const _StrA sKey= "\\highlight";
_Array<_CharType> ctArray = { _CharType::ArabicDigit };
_Pair<int,int> pos = _text.PowerIndexOf(sKey, ctArray, 1);
char* pText = (char*)(_text.Data);
while (pos.First != -1 && pos.Second != -1)
{
//d.PrintError(_getc(pos));
//把 highlight1 highlight10 改为 highlight0 highlight00
for (int i = pos.First + sKey.Length; i <= pos.Second; ++i)
{
if (gs.c_IsArabicDigit(pText[i]))
{
pText[i] = '0';
}
}
pos = _text.PowerIndexOf(sKey, ctArray, pos.Second + 1);
}
return _text;
} /// <summary>
/// 返回右边配对字符的位置
/// </summary>
/// <param name="sText"></param>
/// <param name="nLeftPos"></param>
/// <param name="cLeft"></param>
/// <returns></returns>
/// 创建时间： 2022-12-18 最后一次修改时间：2022-12-18 已测试（2022-12-18）
int IndexOfRightPairChar(const int nLeftPos, const _char cLeft, const _char cRight)const
{
return gs.s_FindRightPairChar_t<T>(_pData, nLeftPos, cLeft, cRight);
}
/// <summary>
/// 向后查找右边配对的字符，例如 { } [ ]
/// </summary>
/// <typeparam name="T">字符串类型</typeparam>
/// <param name="sText">文本</param>
/// <param name="nLeftPos">第一个字符出现的位置</param>
/// <param name="cLeft">第一个字符</param>
/// <param name="cRight">第二个字符</param>
/// <returns></returns>
template<class T>
static int s_FindRightPairChar_t(const T* sText, const int nLeftPos, const T& cLeft, const T& cRight)
{
int iFlag = 0;
int n = nLeftPos + 1;
while (sText[n] != 0)
{
T c = sText[n];
if (c == cRight)
{
if (iFlag == 0) { return n; }
--iFlag;
}
else if (c == cLeft)
{
++iFlag;
}
++n;
}
return -1;
}
/// <summary>
/// 查找第一次出现的子串，且子串后面的字符按一定的规则排列，： 第一种字符是 CharType1, 第二种是 CharType2 类型 ，依次类推.
/// 例 ：
/// _Array<_CharType> ctArray = { _CharType::Digit,_CharType::EnglishLetters, _CharType::WhiteSpace };
/// _StrA s = "s1s1s s1a S2a W";
/// _pcn(s3.PowerIndexOf("s", ctArray)); 结果是 2,5
/// _pcn(s3.PowerIndexOf("s", ctArray, 10)); 结果是 -1,-1
/// _pcn(s3.PowerIndexOf("s", ctArray, 10, false)); 结果是 10,13
/// </summary>
/// <param name="sPartOne">第一部分字符</param>
/// <param name="ctArrayOtherPart">其它部分字符规则</param>
/// <param name="nPosStart">查找开始的位置</param>
/// <param name="bMatchCase">是否大小写匹配</param>
/// <returns>找到返回第一个字符的位置和最后一个字符的位置</returns>
/// 创建时间： 2022-02-20 最后一次修改时间：2022-02-21 已测试（2023-02-21）
_Pair<int, int> PowerIndexOf(const _Str<T> &sPartOne, const _Array<_CharType> ctArrayOtherPart, const int nPosStart = 0, bool bMatchCase = true)
{
/*
pPartOneLength[] 是长度计算的形式参数，在 main)() 函数中调用时，pPartOneLength 是一个指向数组第一个元素的指针。在执行 main() 函数时，
不知道 pPartOneLength 所表示的地址有多大的数据存储空间，只是告诉函数：一个数据存储空间首地址。
sizoef pPartOneLength 的结果是指针变量 pPartOneLength 占内存的大小，一般在 64 位机上是8个字节。a[0] 是 int 类型，
sizeof a[0] 是4个字节，结果是2。
在C/C++函数中计算传入的数组的长度是不可取的
*/
_Pair<int, int> paResult(-1, -1);
int iStart = nPosStart >= 0 ? nPosStart : 0;
if (iStart >= _nLength) return paResult;
int nEnd = _nLength - sPartOne._nLength;
int nAarryOtherPartLength = ctArrayOtherPart.Length;
for (int i = iStart; i <= nEnd; ++i)
{
bool bFind = true;
for (int j = 0; j < sPartOne._nLength; ++j)
{
if (bMatchCase)
{
if (_pData[i + j] != sPartOne._pData[j])
{
bFind = false;
break;
}
}
else
{
if (gcf.gcf_tolower(_pData[i + j]) != gcf.gcf_tolower(sPartOne._pData[j]))
{
bFind = false;
break;
}
}
}
//比较第二部份
if (bFind)
{
paResult.First = i;
int iStart = i + sPartOne._nLength;
int k = 0;
int n = 0;
int nCount = 0;
while (true)
{
bool bFinish = false;
for (n = 0; n < nAarryOtherPartLength; ++n)
{
if (ctArrayOtherPart[n] == _CharType::ArabicDigit)
{
//向后查找第一个不是数字的字符
bool bHave = false;
for (k = iStart; k < _nLength; ++k)
{
if (!gs.c_IsArabicDigit(_pData[k]))
{
iStart = k; //下次开始比较的位置
if (bHave)
{
if (n == nAarryOtherPartLength - 1) //一轮比较完成
{
paResult.Second = k -1;
bFinish = true;
++nCount;
}
}
break;
}
else
{
bHave = true;
if (k == _nLength - 1) //栓果是否最后一个字符
{
if (n == nAarryOtherPartLength - 1)
{
paResult.Second = k;
}
return paResult;
}
}
}
}
else if (ctArrayOtherPart[n] == _CharType::Punctuation)
{
//向后查找第一个不是标点符号的字符
bool bHave = false;
for (k = iStart; k < _nLength; ++k)
{
if (!gs.c_IsPunctuation(_pData[k]))
{
iStart = k; //下次开始比较的位置
if (bHave)
{
if (n == nAarryOtherPartLength - 1) //一轮比较完成
{
paResult.Second = k - 1;
bFinish = true;
++nCount;
}
}
break;
}
else
{
bHave = true;
if (k == _nLength - 1) //栓果是否最后一个字符
{
if (n == nAarryOtherPartLength - 1)
{
paResult.Second = k;
}
return paResult;
}
}
}
}
else if (ctArrayOtherPart[n] == _CharType::EnglishLetters)
{
//向后查找第一个不是英文字母的字符
bool bHave = false;
for (k = iStart; k < _nLength; ++k)
{
if (!gs.c_IsEnglishLetters(_pData[k]))
{
iStart = k; //下次开始比较的位置
if (bHave)
{
if (n == nAarryOtherPartLength - 1) //一轮比较完成
{
paResult.Second = k -1;
bFinish = true;
++nCount;
}
}
break;
}
else
{
bHave = true;
if (k == _nLength - 1) //栓果是否最后一个字符
{
if (n == nAarryOtherPartLength - 1)
{
paResult.Second = k;
}
return paResult;
}
}
}
}
else if (ctArrayOtherPart[n] == _CharType::WhiteSpace)
{
//向后查找第一个不是空格的字符
bool bHave = false;
for (k = iStart; k < _nLength; ++k)
{
if (!gs.c_IsWhiteSpace(_pData[k]))
{
iStart = k; //下次开始比较的位置
if (bHave)
{
if (n == nAarryOtherPartLength - 1) //一轮比较完成
{
paResult.Second = k - 1;
bFinish = true;
++nCount;
}
}
break;
}
else
{
bHave = true;
if (k == _nLength - 1) //栓果是否最后一个字符
{
if (n == nAarryOtherPartLength - 1)
{
paResult.Second = k;
}
return paResult;
}
}
}
}
else
{
throw("未知字符类型！");
}
}
if (!bFinish) //退出 while 循环
{
break;
}
}
if (nCount > 0) //已找到匹配字符串
{
return paResult;
}
}
}
return paResult;
}
/// <summary>
/// 字符类型
/// </summary>
/// 创建时间：2023-02-19 最后一次修改时间：2023-02-19
enum class _CharType
{
/// <summary>
/// 阿拉伯数字 0 ~ 10
/// </summary>
ArabicDigit,
/// <summary>
/// 英文字母 a~z A~Z
/// </summary>
EnglishLetters,
/// <summary>
/// 标点符号
/// </summary>
Punctuation,
/// <summary>
/// 空格
/// </summary>
WhiteSpace,
/// <summary>
/// 中文汉字
/// </summary>
ChineseCharacter,
/// <summary>
/// 数字，包括阿拉伯数字和中文数字，这个数字要不全是阿拉伯数字，要不全是中文小写数字或者全是中文大写数字。
/// </summary>
Number,
/// <summary>
/// 控制字符或者空格
/// </summary>
ControlOrWhiteSpace,
};
