开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
Text.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：31k
源码类别：

模拟服务器

开发平台：

C/C++

Text.cpp：源码内容
  1. /*****************************************************************************************
  2. // 文字串处理
  3. // Copyright : Kingsoft 2002
  4. // Author :   Wooy(Wu yue)
  5. // CreateTime: 2002-8-31
  6. ------------------------------------------------------------------------------------------
  7. *****************************************************************************************/
  8. #include "KWin32.h"
  9. #include <string.h>
  10. #ifndef __linux
  11. #include <crtdbg.h>
  12. #else
  13. #define HRESULT long
  14. #define S_OK 0
  15. #endif
  17. #include "Text.h"
  18. #define MAX_ENCODED_CTRL_LEN 4 //单个控制符（控制标识+控制参数）的最大存储长度
  21. IInlinePicEngineSink* g_pIInlinePicSink = NULL; //嵌入式图片的处理接口[wxb 2003-6-19]
  22. extern "C" ENGINE_API HRESULT 
  23. AdviseEngine(IInlinePicEngineSink* pSink)
  24. {
  25. _ASSERT(NULL == g_pIInlinePicSink); //一般不会挂接两次
  26. g_pIInlinePicSink = pSink;
  27. return S_OK;
  28. }
  30. extern "C" ENGINE_API HRESULT 
  31. UnAdviseEngine(IInlinePicEngineSink* pSink)
  32. {
  33. if (pSink == g_pIInlinePicSink)
  34. g_pIInlinePicSink = NULL;
  35. return S_OK;
  36. }
  38. //检测某个字符是否为不许放置行首的字符
  39. #define NUM_CHARACTER_IN_A1 11
  40. unsigned char s_NotAllowAtLineHeadA1Characters[NUM_CHARACTER_IN_A1] = 
  41. {
  42.  //、。’〕〉》」』〗】
  43. 0xa2, 0xa3, 0xaf, 0xb1, 0xb3, 0xb5, 0xb7, 0xb9, 0xbb, 0xbd, 0xbf
  44. };
  45. #define NUM_CHARACTER_IN_A3 10
  46. unsigned char s_NotAllowAtLineHeadA3Characters[NUM_CHARACTER_IN_A3] = 
  47. {
  48. //！   ）    ，   ．     ：    ；   ＞    ？    ］    ｝
  49. 0xa1, 0xa9, 0xac, 0xae, 0xba, 0xbb, 0xbe, 0xbf, 0xdd, 0xfd
  50. };
  51. #define NUM_CHARACTER_IN_00 7
  52. unsigned char s_NotAllowAtLineHead00Characters[NUM_CHARACTER_IN_00] =
  53. {
  54. //!),.:;>?
  55. 0x21, 0x29, 0x2c, /*0x2e,*/ 0x3a, 0x3b, 0x3e, 0x3f
  56. };
  58. //检测某个字符是否为不许放置行首的字符，不是限制字符则返回0，否则返回字符占的子节数
  59. extern "C" ENGINE_API
  60. int TIsCharacterNotAlowAtLineHead(const char* pCharacter)
  61. {
  62. int i;
  63. unsigned char cChar;
  64. cChar = (unsigned char)(*pCharacter);
  65. if (cChar == 0xa3)
  66. {
  67. cChar = (unsigned char)pCharacter[1];
  68. if (cChar >= 0xa1 && cChar <= 0xfd)
  69. {
  70. for (i = 0; i < NUM_CHARACTER_IN_A3; i++)
  71. if (s_NotAllowAtLineHeadA3Characters[i] == cChar)
  72. return 2;
  73. }
  74. }
  75. else if (cChar == 0xa1)
  76. {
  77. cChar = (unsigned char)pCharacter[1];
  78. if (cChar >= 0xa2 && cChar <= 0xbf)
  79. {
  80. for (i = 0; i < NUM_CHARACTER_IN_A1; i++)
  81. if (s_NotAllowAtLineHeadA1Characters[i] == cChar)
  82. return 2;
  83. }
  84. }
  85. else if (cChar >= 0x21 && cChar <= 0x3f)
  86. {
  87. for (i = 0; i < NUM_CHARACTER_IN_00; i++)
  88. if (s_NotAllowAtLineHead00Characters[i] == cChar)
  89. return 1;
  90. }
  91. return false;
  92. }
  94. //获取本行的下个显示字符
  95. extern "C" ENGINE_API
  96. const char* TGetSecondVisibleCharacterThisLine(const char* pCharacter, int nPos, int nLen)
  97. {
  98. if (pCharacter && nLen > 0)
  99. {
  100. bool bFoundFirst = false;
  101. while(nPos < nLen)
  102. {
  103. unsigned char cChar = (unsigned char)(pCharacter[nPos]);
  104. if (cChar >= 0x20)
  105. {
  106. if (bFoundFirst)
  107. return (pCharacter + nPos);
  108. bFoundFirst = true;
  109. if (cChar > 0x80)
  110. nPos += 2;
  111. else
  112. nPos ++;
  113. continue;
  114. }
  115. if (cChar == KTC_COLOR || cChar == KTC_BORDER_COLOR)
  116. nPos += 4;
  117. else if (cChar == KTC_INLINE_PIC)
  118. nPos += 1 + sizeof(WORD);
  119. else if (cChar == KTC_COLOR_RESTORE || cChar == KTC_BORDER_RESTORE)
  120. nPos++;
  121. break;
  122. };
  123. }
  124. return NULL;
  125. }
  128. //--------------------------------------------------------------------------
  129. // 功能：寻找分割字符串的合适位置
  130. // 参数：pString    --> 想要分割的字符串
  131. // 　nDesirePos --> 期望分割的位置（以字节为单位）
  132. //   bLess      --> 如果期望分割的位置处于一个字符编码的中间时，结果位置
  133. // 为前靠还是后靠，0: 向后靠; 非0: 向前靠。
  134. // 注释：Chinese GBK编码版本，此字符串中字符全部视为显示字符，不包含控制字符
  135. //--------------------------------------------------------------------------
  136. extern "C" ENGINE_API
  137. int TSplitString(const char* pString, int nDesirePos, int bLess)
  138. {
  139. register int nPos = 0;
  140. if (pString)
  141. {
  142. nDesirePos -= 2;
  143. while(nPos < nDesirePos)
  144. {
  145. if ((unsigned char)pString[nPos] > 0x80)
  146. nPos += 2;
  147. else if (pString[nPos])
  148. nPos++;
  149. else
  150. break;
  151. };
  152. nDesirePos += 2;
  153. while(nPos < nDesirePos)
  154. {
  155. if ((unsigned char)pString[nPos] > 0x80)
  156. {
  157. if (bLess && (nPos + 2 > nDesirePos))
  158. break;
  159. if (pString[nPos + 1] == 0)
  160. {//防止出现单BYTE的高于0x80的字符
  161. nPos ++;
  162. break;
  163. }
  164. nPos += 2;
  165. }
  166. else if (pString[nPos])
  167. nPos ++;
  168. else
  169. break;
  170. }
  171. }
  172. return nPos;
  173. }
  175. //--------------------------------------------------------------------------
  176. // 功能：在编码字串寻找分割字符串的合适位置
  177. // 参数：pString    --> 想要分割的字符串
  178. //   nCount  -->字符串内容的长度（以字节为单位）
  179. // 　nDesirePos --> 期望分割的位置（以缓冲驱存储字节为单位）
  180. //   bLess      --> 如果期望分割的位置处于一个中文字符编码的中间时，
  181. // 结果位置为前靠还是后靠，0: 向后靠; 非0: 向前靠。
  182. // 注释：Chinese GBK编码版本，此字符串中可包含已经编码的控制符
  183. //--------------------------------------------------------------------------
  184. extern "C" ENGINE_API
  185. int TSplitEncodedString(const char* pString, int nCount, int nDesirePos, int bLess)
  186. {
  187. int nPos = 0;
  188. if (pString)
  189. {
  190. if (nDesirePos <= nCount)
  191. {
  192. register unsigned char cCharacter;
  193. nDesirePos -= MAX_ENCODED_CTRL_LEN;
  194. while (nPos < nDesirePos)
  195. {
  196. cCharacter = (unsigned char)pString[nPos];
  197. if (cCharacter > 0x80)
  198. nPos += 2;
  199. else if (cCharacter == KTC_COLOR || cCharacter == KTC_BORDER_COLOR)
  200. nPos += 4;
  201. else if (cCharacter == KTC_INLINE_PIC)
  202. nPos += 3;//1 + sizeof(WORD);
  203. else
  204. nPos ++;
  205. }
  206. nPos += MAX_ENCODED_CTRL_LEN;
  207. while(nPos < nDesirePos)
  208. {
  209. cCharacter = (unsigned char)pString[nPos];
  210. if (cCharacter > 0x80)
  211. {
  212. if (bLess && (nPos + 2 > nDesirePos))
  213. break;
  214. if (nPos + 1 == nCount)
  215. {//防止出现单BYTE的高于0x80的字符
  216. nPos = nCount;
  217. break;
  218. }
  219. nPos += 2;
  220. }
  221. else if (cCharacter == KTC_INLINE_PIC)
  222. {
  223. if (bLess && nPos + 3 > nDesirePos)
  224. break;
  225. if (nPos + 3 >= nCount)
  226. {
  227. nPos = nCount;
  228. break;
  229. }
  230. nPos += 3;//1 + sizeof(WORD);
  231. }
  232. else if (cCharacter == KTC_COLOR || cCharacter == KTC_BORDER_COLOR)
  233. {
  234. if (bLess && (nPos + 4 > nDesirePos))
  235. break;
  236. if (nPos + 4 >= nCount)
  237. {
  238. nPos = nCount;
  239. break;
  240. }
  241. nPos += 4;
  242. }
  243. else
  244. nPos ++;
  245. }
  247. }
  248. else
  249. {
  250. nPos = nCount;
  251. }
  252. }
  253. return nPos;
  255. }
  258. //字符换控制码的字符标记表示与内部编码的对应结构
  259. #define KTC_CTRL_CODE_MAX_LEN 7
  260. typedef struct _KCtrlTable
  261. {
  262. char    szCtrl[KTC_CTRL_CODE_MAX_LEN + 1]; //字符换控制码的字符表示
  263. short nCtrlLen; //字符换控制码的字符表示的长度
  264. short   nCtrl; //字符换控制码的内部编码
  265. }KCtrlTable;
  267. //控制码列表
  268. static const KCtrlTable s_CtrlTable[] =
  269. {
  270. { "enter", 5, KTC_ENTER },
  271. { "color", 5, KTC_COLOR },
  272. { "bclr", 4, KTC_BORDER_COLOR },
  273. { "pic", 3, KTC_INLINE_PIC },
  274. };
  276. //控制码的数目
  277. static const int s_nCtrlCount = sizeof(s_CtrlTable)/sizeof(KCtrlTable);
  279. //颜色结构
  280. typedef struct _KColorTable
  281. {
  282. char Token[8]; //颜色的字符表示
  283. unsigned char Red; //颜色的R分量
  284. unsigned char Green; //颜色的G分量
  285. unsigned char Blue; //颜色的B分量
  286. }KColorTable;
  288. //颜色列表
  289. static const KColorTable s_ColorTable[] =
  290. {
  291. { "Black", 0, 0, 0 },
  292. { "White", 255, 255, 255 },
  293. { "Red", 255, 0, 0 },
  294. { "Green", 0, 255, 0 },
  295. { "Blue", 100, 100, 255 },
  296. { "Yellow", 255, 255, 0 },
  297. { "Pink", 255, 0, 255 },
  298. { "Cyan", 0, 255, 255 },
  299. { "Metal", 246, 255, 117 },
  300. { "Wood", 0, 255, 120 },
  301. { "Water", 78, 124, 255 },
  302. { "Fire", 255, 90, 0 },
  303. { "Earth", 254, 207, 179 },
  304. { "DBlue", 120, 120, 120 },
  305. { "HBlue", 100, 100, 255 },
  306. };
  308. //颜色的数目
  309. static const int s_nColorCount = sizeof(s_ColorTable)/sizeof(KColorTable);
  311. //嵌入图片[wxb 2003-6-19]
  312. #define MAXPICTOKENLEN 16
  315. static bool TEncodeCtrl(char* pBuffer, int nCount, int& nReadPos, int& nShortCount);
  316. static int  TEncodeCtrl(int nCtrl, char* pParamBuffer, int nParamLen, char* pEncodedBuffer);
  318. //--------------------------------------------------------------------------
  319. // 功能：对文本串中的控制标记进行转换，去除无效字符，缩短文本串存储长度
  320. //--------------------------------------------------------------------------
  321. extern "C" ENGINE_API
  322. int TEncodeText(char* pBuffer, int nCount)
  323. {
  324. int nShortCount = 0;
  325. if (pBuffer)
  326. {
  327. unsigned char cCharacter;
  328. int nReadPos = 0;
  329. while(nReadPos < nCount)
  330. {
  331. cCharacter = pBuffer[nReadPos];
  332. if (cCharacter > 0x80)
  333. {
  334. if (nReadPos + 1 < nCount) //是可能是中文文字
  335. {
  336. pBuffer[nShortCount++] = cCharacter;
  337. pBuffer[nShortCount++] = pBuffer[nReadPos+ 1];
  338. nReadPos += 2;
  339. }
  340. else //大于0x80的单字节西文字符被过滤掉
  341. break;
  342. }
  343. else if (cCharacter == 0x0d) //换行
  344. {
  345. if (nReadPos + 1 < nCount && pBuffer[nReadPos + 1] == 0x0a)
  346. nReadPos += 2;
  347. else
  348. nReadPos ++;
  349. pBuffer[nShortCount++] = 0x0a;
  350. }
  351. else if (pBuffer[nReadPos] == '<')
  352. TEncodeCtrl(pBuffer, nCount, nReadPos, nShortCount);
  353. else if((cCharacter >= 0x20 && cCharacter < 0x7F) ||
  354. cCharacter == 0x0a || cCharacter == 0x09)
  355. {
  356. pBuffer[nShortCount++] = cCharacter;
  357. nReadPos++;
  358. }
  359. else
  360. nReadPos++;
  361. }
  362. if (nShortCount <nCount)
  363. pBuffer[nShortCount] = 0;
  364. }
  365. return nShortCount;
  366. }
  368. //--------------------------------------------------------------------------
  369. // 功能：对文本串中的控制标记进行转换，去除无效字符，缩短文本串存储长度
  370. //--------------------------------------------------------------------------
  371. extern "C" ENGINE_API
  372. int TFilterEncodedText(char* pBuffer, int nCount)
  373. {
  374. int nShortCount = 0;
  375. if (pBuffer)
  376. {
  377. unsigned char cCharacter;
  378. int nReadPos = 0;
  379. while(nReadPos < nCount)
  380. {
  381. cCharacter = pBuffer[nReadPos];
  382. if (cCharacter > 0x80)
  383. {
  384. if (nReadPos + 1 < nCount) //是可能是中文文字
  385. {
  386. pBuffer[nShortCount++] = cCharacter;
  387. pBuffer[nShortCount++] = pBuffer[nReadPos+ 1];
  388. nReadPos += 2;
  389. }
  390. else //大于0x80的单字节西文字符被过滤掉
  391. {
  392. nReadPos++;
  393. break;
  394. }
  395. }
  396. else if ((cCharacter >= 0x20 && cCharacter < 0x7F) ||
  397. cCharacter == 0x0a || cCharacter == 0x09)
  398. {
  399. pBuffer[nShortCount++] = cCharacter;
  400. nReadPos++;
  401. }
  402. else if (cCharacter == KTC_COLOR || cCharacter == KTC_BORDER_COLOR)
  403. {
  404. if (nReadPos + 4 < nCount)
  405. {
  406. *(int*)(pBuffer + nShortCount) = *(int*)(pBuffer + nReadPos);
  407. nShortCount += 4;
  408. nReadPos += 4;
  409. }
  410. else
  411. {
  412. nReadPos++;
  413. break;
  414. }
  415. }
  416. else if (cCharacter == KTC_INLINE_PIC)
  417. {
  418. if ((int)(nReadPos + 1 + sizeof(WORD)) < nCount)
  419. {
  420. memcpy(pBuffer + nShortCount, pBuffer + nReadPos, 1 + sizeof(WORD));;
  421. nShortCount += 1 + sizeof(WORD);
  422. nReadPos += 1 + sizeof(WORD);
  423. }
  424. else
  425. {
  426. nReadPos++;
  427. break;
  428. }
  429. }
  430. else
  431. nReadPos ++;
  432. }
  433. if (nShortCount < nCount)
  434. pBuffer[nShortCount] = 0;
  435. }
  437. return nShortCount;
  438. }
  440. //--------------------------------------------------------------------------
  441. // 功能：分析转换控制符
  442. //--------------------------------------------------------------------------
  443. static bool TEncodeCtrl(char* pBuffer, int nCount, int& nReadPos, int& nShortCount)
  444. {
  446. _ASSERT(pBuffer != NULL && nReadPos < nCount && nShortCount < nCount && nShortCount <= nReadPos);
  448. int nCtrlCodeSize, nEndPos, nCtrl;
  450. //寻找结束符号'='的位置或'>'的位置
  451. int nEqualPos = nReadPos + 1;
  452. for (; nEqualPos < nCount && nEqualPos <= nReadPos + KTC_CTRL_CODE_MAX_LEN; nEqualPos++)
  453. if (pBuffer[nEqualPos] == '>' || pBuffer[nEqualPos] == '=')
  454. break;
  456. if(nEqualPos >= nCount || nEqualPos > nReadPos + KTC_CTRL_CODE_MAX_LEN)
  457. goto NO_MATCHING_CTRL; //未找到'='或者'>'结束符号
  459. nCtrlCodeSize = nEqualPos - nReadPos - 1; //控制命令符号的长度
  461. for (nCtrl = 0; nCtrl < s_nCtrlCount; nCtrl++)
  462. {
  463. if (nCtrlCodeSize ==  s_CtrlTable[nCtrl].nCtrlLen &&
  464. memcmp(pBuffer + nReadPos + 1, s_CtrlTable[nCtrl].szCtrl, nCtrlCodeSize) == 0)
  465. break;
  466. }
  467. if (nCtrl >= s_nCtrlCount) //未找到匹配一致的控制命令
  468. goto NO_MATCHING_CTRL;
  469. nCtrl = s_CtrlTable[nCtrl].nCtrl;
  471. nEndPos = nEqualPos;
  472. if (pBuffer[nEqualPos] != '>')
  473. {
  474. for(nEndPos++; nEndPos < nCount; nEndPos++)
  475. if (pBuffer[nEndPos] == '>')
  476. break;
  477. if (nEndPos >= nCount)
  478. goto NO_MATCHING_CTRL;
  479. nShortCount += TEncodeCtrl(nCtrl, pBuffer + nEqualPos + 1,
  480. nEndPos - nEqualPos - 1, pBuffer + nShortCount);
  481. }
  482. else
  483. nShortCount += TEncodeCtrl(nCtrl, NULL, 0, pBuffer + nShortCount);
  484. nReadPos = nEndPos + 1;
  485. return true;
  487. NO_MATCHING_CTRL:
  488. pBuffer[nShortCount++] = '<';
  489. nReadPos++;
  490. return false;
  491. }
  493. //--------------------------------------------------------------------------
  494. // 功能：转换并存储控制命令及各控制参数
  495. //--------------------------------------------------------------------------
  496. static int TEncodeCtrl(int nCtrl, char* pParamBuffer, int nParamLen, char* pEncodedBuffer)
  497. {
  498. _ASSERT(pEncodedBuffer && (nParamLen == 0 || pParamBuffer != NULL));
  500. int nEncodedSize = 0;
  501. static char Color[8];
  502. static char szPic[MAXPICTOKENLEN];
  504. switch(nCtrl)
  505. {
  506. case KTC_ENTER:
  507. pEncodedBuffer[nEncodedSize ++] = nCtrl;
  508. break;
  509. case KTC_INLINE_PIC: //[wxb 2003-6-19]
  510. if (nParamLen == 0 && nParamLen >= MAXPICTOKENLEN)
  511. break;
  512. {
  513. memcpy(szPic, pParamBuffer, nParamLen);
  514. szPic[nParamLen] = 0;
  515. pEncodedBuffer[nEncodedSize] = KTC_INLINE_PIC;
  516. *((WORD*)(pEncodedBuffer + nEncodedSize + 1)) = atoi(szPic);
  517. nEncodedSize += 1 + sizeof(WORD);
  518. }
  519. break;
  520. case KTC_COLOR:
  521. if (nParamLen == 0)
  522. {
  523. pEncodedBuffer[nEncodedSize ++] = KTC_COLOR_RESTORE;
  524. }
  525. else if (nParamLen < 8)
  526. {
  527. memcpy(Color, pParamBuffer, nParamLen);
  528. Color[nParamLen] = 0;
  529. for (int i = 0; i < s_nColorCount; i++)
  530. {
  531. #ifndef __linux
  532. if (stricmp(Color,s_ColorTable[i].Token) == 0)
  533. #else
  534. if(strcasecmp(Color,s_ColorTable[i].Token) == 0)
  535. #endif
  536. {
  537. pEncodedBuffer[nEncodedSize] = KTC_COLOR;
  538. pEncodedBuffer[nEncodedSize + 1]= s_ColorTable[i].Red;
  539. pEncodedBuffer[nEncodedSize + 2]= s_ColorTable[i].Green;
  540. pEncodedBuffer[nEncodedSize + 3]= s_ColorTable[i].Blue;
  541. nEncodedSize += 4;
  542. break;
  543. }
  544. }
  545. }
  546. break;
  547. case KTC_BORDER_COLOR:
  548. if (nParamLen == 0)
  549. {
  550. pEncodedBuffer[nEncodedSize ++] = KTC_BORDER_RESTORE;
  551. }
  552. else if (nParamLen < 8)
  553. {
  554. memcpy(Color, pParamBuffer, nParamLen);
  555. Color[nParamLen] = 0;
  556. for (int i = 0; i < s_nColorCount; i++)
  557. {
  558. #ifndef __linux
  559. if (stricmp(Color,s_ColorTable[i].Token) == 0)
  560. #else
  561. if(strcasecmp(Color,s_ColorTable[i].Token) == 0)
  562. #endif
  563. // if (stricmp(Color,s_ColorTable[i].Token) == 0)
  564. {
  565. pEncodedBuffer[nEncodedSize] = KTC_BORDER_COLOR;
  566. pEncodedBuffer[nEncodedSize + 1]= s_ColorTable[i].Red;
  567. pEncodedBuffer[nEncodedSize + 2]= s_ColorTable[i].Green;
  568. pEncodedBuffer[nEncodedSize + 3]= s_ColorTable[i].Blue;
  569. nEncodedSize += 4;
  570. break;
  571. }
  572. }
  573. }
  574. break;
  575. }
  576. return nEncodedSize;
  577. }
  579. extern "C" ENGINE_API
  580. int TRemoveCtrlInEncodedText(char* pBuffer, int nCount)
  581. {
  582. int nLen = 0;
  583. nCount = TFilterEncodedText(pBuffer, nCount);
  584. for (int nPos = 0; nPos < nCount; nPos++)
  585. {
  586. char cCharacter = pBuffer[nPos];
  587. if (cCharacter == KTC_COLOR || cCharacter == KTC_BORDER_COLOR)
  588. nPos += 3;
  589. else if (cCharacter == KTC_INLINE_PIC)
  590. nPos += sizeof(WORD);
  591. else if (cCharacter != KTC_COLOR_RESTORE && cCharacter != KTC_BORDER_RESTORE)
  592. {
  593. pBuffer[nLen] = cCharacter;
  594. nLen ++;
  595. }
  596. }
  597. return nLen;
  598. }
  600. //获取编码文本的行数与最大行宽
  601. //参数：pBuffer 文本缓冲区
  602. // nCount 文本数据的长度
  603. // nWrapCharaNum 限制每行不许超过的字符数目
  604. // nMaxLineLen 用于获取文本的实际最大行宽（字符数目）
  605. // nFontSize 采用字体的大小 [wxb 2003-6-19]
  606. // nSkipLine 跳过前面多少行的数据
  607. // nNumLineLimit 检测的文本的行数，超过限制行数目之后的内容被忽略。如果此值小于等于0则表示无此限制。
  608. //返回：文本的行数
  609. //extern "C" ENGINE_API
  610. //int TGetEncodedTextLineCount(const char* pBuffer, int nCount, int nWrapCharaNum, int& nMaxLineLen, int nFontSize, int nSkipLine = 0, int nNumLineLimit = 0)
  611. extern "C" ENGINE_API
  612. int TGetEncodedTextLineCount(const char* pBuffer, int nCount, int nWrapCharaNum, int& nMaxLineLen, int nFontSize, int nSkipLine, int nNumLineLimit,
  613.  BOOL bPicSingleLine/* = FALSE*/)
  614. {
  615. //设一个极值免得出错 [wxb 2003-6-20]
  616. _ASSERT(nFontSize >= 4 && nFontSize < 64);
  617. nFontSize = max(4, nFontSize);
  618. nFontSize = min(64, nFontSize);
  620. float fMaxLineLen = 0;
  621. nMaxLineLen = 0;
  622. if (pBuffer == 0)
  623. return 0;
  625. if (nCount < 0)
  626. nCount = strlen(pBuffer);
  628. float fNumChars = 0;
  629. int nNumLine = 0;
  630. int nPos = 0;
  631. unsigned char cCode;
  633. if (nWrapCharaNum <= 0)
  634. nWrapCharaNum = 0x7fffffff;
  635. if (nSkipLine < 0)
  636. nSkipLine = 0;
  637. if (nNumLineLimit <= 0)
  638. nNumLineLimit = 0x7fffffff;
  640. bool bNextLine = false;
  641. float fNumNextLineChar = 0;
  642. int  nExtraLineForInlinePic = 0;
  643. while(nPos < nCount)
  644. {
  645. cCode = pBuffer[nPos];
  646. if (cCode > 0x80) //可能是中文字符
  647. {
  648. nPos += 2;
  649. if (fNumChars + 2 < nWrapCharaNum)
  650. fNumChars += 2;
  651. else if (fNumChars + 2 == nWrapCharaNum || fNumChars == 0)
  652. {
  653. bNextLine = true;
  654. fNumChars += 2;
  655. }
  656. else
  657. {
  658. bNextLine = true;
  659. fNumNextLineChar = 2;
  660. }
  661. }
  662. else if (cCode == KTC_COLOR || cCode == KTC_BORDER_COLOR)//颜色控制
  663. nPos += 4;
  664. else if (cCode == KTC_INLINE_PIC)
  665. {
  666. //嵌入式图片处理 [wxb 2003-6-19]
  667. WORD wPicIndex = *((WORD*)(pBuffer + nPos + 1));
  668. nPos += 1 + sizeof(WORD);
  669. if (g_pIInlinePicSink)
  670. {
  671. int nWidth, nHeight;
  672. if (SUCCEEDED(g_pIInlinePicSink->GetPicSize(wPicIndex, nWidth, nHeight)))
  673. {
  674. if (nHeight > nFontSize)
  675. {
  676. int nExtraLines = nHeight - nFontSize;
  677. nExtraLines = nExtraLines / nFontSize + ((nExtraLines % nFontSize) ? 1 : 0);
  678. if (nExtraLines > nExtraLineForInlinePic && !bPicSingleLine)
  679. nExtraLineForInlinePic = nExtraLines;
  680. }
  681. if (fNumChars + (((float)nWidth) * 2 / nFontSize) < nWrapCharaNum)
  682. fNumChars += ((float)nWidth) * 2 / nFontSize;
  683. else if (fNumChars + (((float)nWidth) * 2 / nFontSize) == nWrapCharaNum || fNumChars == 0)
  684. {
  685. bNextLine = true;
  686. fNumChars += ((float)nWidth) * 2 / nFontSize;
  687. }
  688. else
  689. {
  690. bNextLine = true;
  691. fNumNextLineChar = ((float)nWidth) * 2 / nFontSize;
  692. }
  693. }
  694. }
  695. }
  696. else if (cCode == KTC_ENTER)
  697. {
  698. nPos ++;
  699. bNextLine = true;
  700. }
  701. else if (cCode != KTC_COLOR_RESTORE && cCode != KTC_BORDER_RESTORE)
  702. {
  703. nPos ++;
  704. fNumChars += 1;
  705. if (fNumChars >= nWrapCharaNum)
  706. {
  707. bNextLine = true;
  708. }
  709. }
  710. else
  711. {
  712. nPos++;
  713. }
  715. if (bNextLine == false && fNumChars && fNumChars + 3 >= nWrapCharaNum)
  716. {
  717. const char* pNext = TGetSecondVisibleCharacterThisLine(pBuffer, nPos, nCount);
  718. if (pNext && TIsCharacterNotAlowAtLineHead(pNext))
  719. bNextLine = true;
  720. }
  721. if (bNextLine)
  722. {
  723. if (nSkipLine > 0)
  724. {
  725. nSkipLine -= 1 + nExtraLineForInlinePic;
  727. //处理图片占多行的情况 [wxb 2003-6-19]
  728. if (nSkipLine < 0)
  729. {
  730. if (fMaxLineLen < fNumChars)
  731. fMaxLineLen = fNumChars;
  732. nNumLine += (-nSkipLine);
  733. if (nNumLine >= nNumLineLimit)
  734. break;
  735. }
  736. }
  737. else
  738. {
  739. if (fMaxLineLen < fNumChars)
  740. fMaxLineLen = fNumChars;
  741. nNumLine += 1 + nExtraLineForInlinePic;
  742. if (nNumLine >= nNumLineLimit)
  743. break;
  744. }
  745. nExtraLineForInlinePic = 0;
  746. fNumChars = (float)fNumNextLineChar;
  747. fNumNextLineChar = 0;
  748. bNextLine = false;
  749. }
  750. }
  751. if (nNumLine < nNumLineLimit && fNumChars && nSkipLine == 0)
  752. {
  753. if (fMaxLineLen < fNumChars)
  754. fMaxLineLen = fNumChars;
  755. nNumLine += 1 + nExtraLineForInlinePic;
  756. }
  758. nMaxLineLen = (int)(fMaxLineLen + (float)0.9999); //进1
  759. return nNumLine;
  760. }
  762. //获得指定行的开始位置
  763. int TGetEncodeStringLineHeadPos(const char* pBuffer, int nCount, int nLine, int nWrapCharaNum, int nFontSize, BOOL bPicSingleLine)
  764. {
  765. //设一个极值免得出错 [wxb 2003-6-20]
  766. _ASSERT(nFontSize > 1 && nFontSize < 64);
  767. nFontSize = max(1, nFontSize);
  768. nFontSize = min(64, nFontSize);
  770. float fMaxLineLen = 0;
  771. if (pBuffer == 0 || nLine <= 0)
  772. return 0;
  774. if (nCount < 0)
  775. nCount = strlen(pBuffer);
  777. float fNumChars = 0;
  778. int  nExtraLineForInlinePic = 0;
  779. int nPos = 0;
  780. unsigned char cCode;
  782. if (nWrapCharaNum <= 0)
  783. nWrapCharaNum = 0x7fffffff;
  785. bool bNextLine = false;
  786. float fNumNextLineChar = 0;
  787. while(nPos < nCount)
  788. {
  789. cCode = pBuffer[nPos];
  790. if (cCode > 0x80) //可能是中文字符
  791. {
  792. nPos += 2;
  793. if (fNumChars + 2 < nWrapCharaNum)
  794. fNumChars += 2;
  795. else if (fNumChars + 2 == nWrapCharaNum || fNumChars == 0)
  796. {
  797. bNextLine = true;
  798. fNumChars += 2;
  799. }
  800. else
  801. {
  802. bNextLine = true;
  803. fNumNextLineChar = 2;
  804. }
  805. }
  806. else if (cCode == KTC_COLOR || cCode == KTC_BORDER_COLOR)//颜色控制
  807. nPos += 4;
  808. else if (cCode == KTC_INLINE_PIC)
  809. {
  810. //嵌入式图片处理 [wxb 2003-6-19]
  811. WORD wPicIndex = *((WORD*)(pBuffer + nPos + 1));
  812. nPos += 1 + sizeof(WORD);
  813. if (g_pIInlinePicSink)
  814. {
  815. int nWidth, nHeight;
  816. if (SUCCEEDED(g_pIInlinePicSink->GetPicSize(wPicIndex, nWidth, nHeight)))
  817. {
  818. if (nHeight > nFontSize)
  819. {
  820. int nExtraLines = nHeight - nFontSize;
  821. nExtraLines = nExtraLines / nFontSize + ((nExtraLines % nFontSize) ? 1 : 0);
  822. if (nExtraLines > nExtraLineForInlinePic && !bPicSingleLine)
  823. nExtraLineForInlinePic = nExtraLines;
  824. }
  825. if (fNumChars + (((float)nWidth) * 2 / nFontSize) < nWrapCharaNum)
  826. fNumChars += ((float)nWidth) * 2 / nFontSize;
  827. else if (fNumChars + (((float)nWidth) * 2 / nFontSize) == nWrapCharaNum || fNumChars == 0)
  828. {
  829. bNextLine = true;
  830. fNumChars += ((float)nWidth) * 2 / nFontSize;
  831. }
  832. else
  833. {
  834. bNextLine = true;
  835. fNumNextLineChar = ((float)nWidth) * 2 / nFontSize;
  836. }
  837. }
  838. }
  839. }
  840. else if (cCode == KTC_ENTER)
  841. {
  842. nPos ++;
  843. bNextLine = true;
  844. }
  845. else if (cCode != KTC_COLOR_RESTORE && cCode != KTC_BORDER_RESTORE)
  846. {
  847. nPos ++;
  848. fNumChars += 1;
  849. if (fNumChars >= nWrapCharaNum)
  850. {
  851. bNextLine = true;
  852. }
  853. }
  854. else
  855. {
  856. nPos++;
  857. }
  859. if (bNextLine == false && fNumChars && fNumChars + 3 >= nWrapCharaNum)
  860. {
  861. const char* pNext = TGetSecondVisibleCharacterThisLine(pBuffer, nPos, nCount);
  862. if (pNext && TIsCharacterNotAlowAtLineHead(pNext))
  863. bNextLine = true;
  864. }
  865. if (bNextLine)
  866. {
  867. // if (nSkipLine > 0)
  868. // {
  869. // nSkipLine -= 1 + nExtraLineForInlinePic;
  870. //
  871. // //处理图片占多行的情况 [wxb 2003-6-19]
  872. // if (nSkipLine < 0)
  873. // {
  874. // if (fMaxLineLen < fNumChars)
  875. // fMaxLineLen = fNumChars;
  876. // nNumLine += (-nSkipLine);
  877. // if (nNumLine >= nNumLineLimit)
  878. // break;
  879. // }
  880. // }
  881. if ((--nLine) == 0)
  882. break;
  883. fNumChars = (float)fNumNextLineChar;
  884. fNumNextLineChar = 0;
  885. bNextLine = false;
  886. }
  887. }
  889. return nPos;
  890. }
  892. extern "C" ENGINE_API
  893. //如果原(包含控制符)字符串长度（包括结尾符）超过限定的长度，则截短它并加上..后缀
  894. const char* TGetLimitLenEncodedString(const char* pOrigString, int nOrigLen, int nFontSize,
  895. int nWrapCharaNum, char* pLimitLenString, int& nShortLen, int nLineLimit, int bPicPackInSingleLine/*=false*/)
  896. {
  897. if (pOrigString == NULL || pLimitLenString == NULL ||
  898. nOrigLen <= 0 || nShortLen < 2 || nLineLimit < 1 || nWrapCharaNum < 2)
  899. {
  900. nShortLen = 0;
  901. return NULL;
  902. }
  904. int nPreLineEndPos = 0, nFinalLineEndPos;
  905. if (nLineLimit > 1) //跳过前面几行
  906. {
  907. nPreLineEndPos = TGetEncodeStringLineHeadPos(pOrigString, nOrigLen, nLineLimit - 1, nWrapCharaNum, nFontSize, bPicPackInSingleLine);
  908. if (nPreLineEndPos > nShortLen)
  909. {
  910. nShortLen = TSplitEncodedString(pOrigString, nOrigLen, nShortLen - 2, true);
  911. memcpy(pLimitLenString, pOrigString, nShortLen);
  912. pLimitLenString[nShortLen] = '.';
  913. pLimitLenString[nShortLen + 1] = '.';
  914. nShortLen += 2;
  915. return pLimitLenString;
  916. }
  917. }
  919. if (nPreLineEndPos < nOrigLen)
  920. {
  921. nFinalLineEndPos = TGetEncodeStringLineHeadPos(pOrigString + nPreLineEndPos,
  922. nOrigLen - nPreLineEndPos, 1, nWrapCharaNum, nFontSize, bPicPackInSingleLine) + nPreLineEndPos;
  923. }
  924. else
  925. nFinalLineEndPos = nOrigLen;
  927. if (nFinalLineEndPos >= nOrigLen)
  928. {
  929. nShortLen = TSplitEncodedString(pOrigString, nOrigLen, nShortLen, true);
  930. memcpy(pLimitLenString, pOrigString, nShortLen);
  931. return pLimitLenString;
  932. }
  934. int nDesireLen = (nFinalLineEndPos <= nShortLen) ? nFinalLineEndPos - 2 : nShortLen - 2;
  936. const char* pFinalLineHead = pOrigString + nPreLineEndPos;
  937. int nRemainCount = nOrigLen - nPreLineEndPos;
  938. nDesireLen -= nPreLineEndPos;
  939. while(true)
  940. {
  941. nShortLen = TSplitEncodedString(pFinalLineHead, nRemainCount, nDesireLen, true);
  942. int nMaxLineLen;
  943. TGetEncodedTextLineCount(pFinalLineHead, nShortLen, 0, nMaxLineLen, nFontSize, 0, 1, FALSE);
  944. if (nMaxLineLen <= nWrapCharaNum - 2)
  945. break;
  946. nDesireLen --;
  947. }
  948. nShortLen += nPreLineEndPos;
  950.     memcpy(pLimitLenString, pOrigString, nShortLen);
  951. pLimitLenString[nShortLen] = '.';
  952. pLimitLenString[nShortLen + 1] = '.';
  953. nShortLen += 2;
  954. return pLimitLenString;
  955. }
  957. //--------------------------------------------------------------------------
  958. // 功能：如果原字符串长度（包括结尾符）超过限定的长度，则截短它并加上..后缀
  959. // 参数：pOrigString     --> 原字符串，要求不为空指针
  960. // 　nOrigLen   --> 原字符串长度（不包括结尾符）
  961. //   pLimitLenString --> 如果原字符串超出限长，用来存储截短后的字符串的缓冲区，要求不为空指针
  962. //   nLimitLen   --> 限定长度，此值要求大于等于3
  963. // 返回：如原字符串不超过限长，则返回原缓冲区指针，否则返回用来存储截短后的字符串的缓冲区的指针
  964. // 注释：Chinese GBK编码版本，此字符串中字符全部视为显示字符，不包含控制字符
  965. //--------------------------------------------------------------------------
  966. extern "C" ENGINE_API
  967. const char* TGetLimitLenString(const char* pOrigString, int nOrigLen, char* pLimitLenString, int nLimitLen)
  968. {
  969. if (pOrigString && pLimitLenString && nLimitLen > 0)
  970. {
  971. if (nOrigLen < 0)
  972. nOrigLen = strlen(pOrigString);
  973. if (nOrigLen < nLimitLen)
  974. return pOrigString;
  975. if (nLimitLen > 2)
  976. {
  977. nOrigLen = TSplitString(pOrigString, nLimitLen - 3, true);
  978. memcpy(pLimitLenString, pOrigString, nOrigLen);
  979. pLimitLenString[nOrigLen] = '.';
  980. pLimitLenString[nOrigLen + 1] = '.';
  981. pLimitLenString[nOrigLen + 2] = 0;
  982. }
  983. else if (nLimitLen == 2)
  984. {
  985. pLimitLenString[0] = '.';
  986. pLimitLenString[1] = 0;
  987. }
  988. return ((nLimitLen >= 2) ? pLimitLenString : NULL);
  989. }
  990. return NULL;
  991. }
  994. //对已经编码的文本，从指定位置开始查找指定的控制符号的位置，返回-1表示未找到
  995. extern "C" ENGINE_API
  996. int TFindSpecialCtrlInEncodedText(const char* pBuffer, int nCount, int nStartPos, char cControl)
  997. {
  998. int nFindPos = -1;
  999. if (pBuffer)
  1000. {
  1001. while(nStartPos < nCount)
  1002. {
  1003. unsigned char cCharacter = pBuffer[nStartPos];
  1004. if ((unsigned char)cControl == cCharacter)
  1005. {
  1006. nFindPos = nStartPos;
  1007. break;
  1008. }
  1009. if (cCharacter > 0x80) //可能是中文文字
  1010. nStartPos += 2;
  1011. else if (cCharacter == KTC_COLOR || cCharacter == KTC_BORDER_COLOR)
  1012. nStartPos += 4;
  1013. else if (cCharacter == KTC_INLINE_PIC)
  1014. nStartPos += 3;
  1015. else
  1016. nStartPos ++;
  1017. }
  1018. }
  1019. return nFindPos;
  1020. }
  1022. //对已经编码的文本，去除指定类型的控制符
  1023. extern "C" ENGINE_API
  1024. int TClearSpecialCtrlInEncodedText(char* pBuffer, int nCount, char cControl)
  1025. {
  1026. int nFinalLen = 0;
  1027. int nReadPos = 0;
  1028. if (pBuffer)
  1029. {
  1030. if ((unsigned char)(cControl) <= 0x80)
  1031. {
  1032. int nMatchLen = 1;
  1033. if (cControl == KTC_COLOR || cControl == KTC_BORDER_COLOR)
  1034. nMatchLen = 4;
  1035. else if (cControl == KTC_INLINE_PIC)
  1036. nMatchLen = 3;
  1037. while(nReadPos < nCount)
  1038. {
  1039. unsigned char cCharacter = pBuffer[nReadPos];
  1040. if ((unsigned char)cControl == cCharacter)
  1041. {
  1042. nReadPos += nMatchLen;
  1043. }
  1044. else if (cCharacter > 0x80)
  1045. {
  1046. short sTemp = *(short*)(pBuffer + nReadPos);
  1047. *(short*)(pBuffer + nFinalLen) = sTemp;
  1048. nReadPos += 2;
  1049. nFinalLen += 2;
  1050. }
  1051. else if (cCharacter == KTC_COLOR || cCharacter == KTC_BORDER_COLOR)
  1052. {
  1053. int nTemp = *(int*)(pBuffer + nReadPos);
  1054. *(int*)(pBuffer + nFinalLen) = nTemp;
  1055. nFinalLen += 4;
  1056. nReadPos += 4;
  1057. }
  1058. else if (cCharacter == KTC_INLINE_PIC)
  1059. {
  1060. memmove((pBuffer + nFinalLen), (pBuffer + nReadPos), 3);
  1061. nFinalLen += 3;
  1062. nReadPos += 3;
  1063. }
  1064. else
  1065. {
  1066. pBuffer[nFinalLen++] = pBuffer[nReadPos++];
  1067. }
  1068. }
  1069. }
  1070. }
  1071. return nFinalLen;
  1072. }
  1074. //对已经编码的文本，指定输出长度的在缓冲区中位置
  1075. extern "C" ENGINE_API
  1076. int TGetEncodedTextOutputLenPos(const char* pBuffer, int nCount, int& nLen, bool bLess, int nFontSize)
  1077. {
  1078. int nIndex = 0, nLenTemp = 0;
  1080. _ASSERT(nFontSize >= 4);
  1081. nFontSize = max(4, nFontSize);
  1083.     if (pBuffer)
  1084. {
  1085. int nWidth, nHeight;
  1086. int nByteCount = 0, nCurCharLen = 0;
  1087.     unsigned char cCharacter        = 0;
  1089. while(nLenTemp < nLen)
  1090. {
  1091. cCharacter = pBuffer[nIndex];
  1092. //计算出当前元素的所占字节数nByteCount和在显示画面上所占宽度nCurCharLen
  1093. if (cCharacter > 0x80) //可能是中文文字
  1094. {
  1095.                 nByteCount  = 2;
  1096. nCurCharLen = 2;
  1097. }
  1098. else if (cCharacter == KTC_COLOR || cCharacter == KTC_BORDER_COLOR)
  1099. {
  1100.     nByteCount  = 4;
  1101. nCurCharLen = 0;
  1102. }
  1103. else if (cCharacter == KTC_COLOR_RESTORE && cCharacter == KTC_BORDER_RESTORE)
  1104. {
  1105. nByteCount  = 1;
  1106. nCurCharLen = 0;
  1107. }
  1108. else if (cCharacter == KTC_INLINE_PIC)
  1109. {
  1110. nByteCount  = 3;
  1111. if(SUCCEEDED(g_pIInlinePicSink->GetPicSize(
  1112. *((unsigned short *)(pBuffer + nIndex + 1)), nWidth, nHeight)))
  1113. {
  1114. nCurCharLen = ((nWidth * 2 + nFontSize - 1) /  nFontSize);
  1115. }
  1116. else
  1117. nCurCharLen = 0;
  1118. }
  1119. else
  1120. {
  1121. nByteCount  = 1;
  1122. nCurCharLen = 1;
  1123. }
  1125. //如果超出缓冲区，就停止吧
  1126. if(nIndex + nByteCount > nCount)
  1127. break;
  1128. //如果宽度还没超过要求宽度
  1129. if(nLenTemp + nCurCharLen < nLen)
  1130. {
  1131. nLenTemp += nCurCharLen;
  1132.         nIndex   += nByteCount;
  1133. }
  1134. //如果宽度等于要求宽度了
  1135. else if(nLenTemp + nCurCharLen == nLen)
  1136. {
  1137. nLenTemp += nCurCharLen;
  1138. nIndex   += nByteCount;
  1139. break;
  1140. }
  1141. //这里就是超过了
  1142. else
  1143. {
  1144. nLenTemp = bLess ? nLenTemp : (nLenTemp + nCurCharLen);
  1145. nIndex   = bLess ? nIndex   : (nIndex + nByteCount);
  1146. break;
  1147. }
  1148. }
  1149. }
  1150. nLen = nLenTemp;
  1151. return nIndex;
  1152. }
  1154. //对已经编码的文本，指定的前段缓冲区中控制符，对后面的输出产生效果影响
  1155. extern "C" ENGINE_API
  1156. int TGetEncodedTextEffectCtrls(const char* pBuffer, int nSkipCount, KTP_CTRL& Ctrl0, KTP_CTRL& Ctrl1)
  1157. {
  1158. int nIndex = 0;
  1159. Ctrl0.cCtrl = Ctrl1.cCtrl = KTC_INVALID;
  1160. if (pBuffer)
  1161. {
  1162. KTP_CTRL PreCtrl0, PreCtrl1;
  1163. PreCtrl0.cCtrl = PreCtrl1.cCtrl = KTC_INVALID;
  1165. while(nIndex < nSkipCount)
  1166. {
  1167. unsigned char cCharacter = pBuffer[nIndex];
  1168. if (cCharacter == KTC_COLOR)
  1169. {
  1170. PreCtrl0  =  Ctrl0;
  1171. *(int*)(&Ctrl0) = *(int*)(pBuffer + nIndex);
  1172. nIndex += 4;
  1173. }
  1174. else if (cCharacter == KTC_BORDER_COLOR)
  1175. {
  1176. PreCtrl1  =  Ctrl1;
  1177. *(int*)(&Ctrl1) = *(int*)(pBuffer + nIndex);
  1178. nIndex += 4;
  1179. }
  1180. else if(cCharacter == KTC_COLOR_RESTORE)
  1181. {
  1182. Ctrl0 = PreCtrl0;
  1183. nIndex ++;
  1184. }
  1185. else if(cCharacter == KTC_BORDER_RESTORE)
  1186. {
  1187. Ctrl1 = PreCtrl1;
  1188. nIndex ++;
  1189. }
  1190. else
  1191. nIndex ++;
  1192. }
  1193. }
  1194. return nIndex;
  1195. }