VS2010複製中文亂碼修復

原創 管哥的天下 2020-02-23 14:52
  當複製VS2010中帶有中文字符的代碼到Office(Word, Excel, PowerPoint, Outlook)時，
在中文字符後面會被添加一到三個亂碼。比如複製"中文字符"，粘貼到word就會變成(中D文?字Á?符¤?)。

 

    通過黑暗執行緒的一篇文章提示，截取剪貼板中RTF(富文本格式)的數據流，並作出修復。該作者使用了 .NET中的正則表達式類RegEx來達到修復目的。方法調用很簡單，感興趣的可以搜索一下作者的博客空間。

 

      我這裏給出另一個解決方法：同時截取CF_UNICODETEXT和RTF兩種剪貼板數據，以CF_UNICODETEXT中的正確數據爲參照，對比剔除RTF中的亂碼。

 

      寫這份代碼走了不少彎路，主要是一開始對RTF格式不熟悉，其中的中文接ASCII碼處理着實讓我差點抓破了頭皮。

 

先給出亂碼修復截圖：

 

 

VS2010CopyModify 

程序添加了全局熱鍵 CTRL+Q 和 監測狀態。右下角則是一個動態文字Logo，鼠標移上去就會出現Logo,

移開則改爲快捷鍵說明。編譯好的文件這裏下載VS2010CopyModify.rar。

 

 

下面貼出程序的核心算法：

 

函數參數說明:

PTSTR        pText     (RTF數據首地址指針，切勿傳遞剪貼板內存，必須是程序拷貝剪貼板的。)

UINT          iText      (RTF數據大小。單位字節)

LPWSTR    pTextU   (CF_UNICODETEXT數據首地址指針，同上，不可爲剪貼板內存。)

UINT          iTextU    (CF_UNICODETEXT數據大小。單位字符)

 

返回值類型  UINT      (修復完後RTF數據的大小。單位字節)

 

/*-------------------------------
  Repair.cpp - 實作亂碼修正處理
  -------------------------------*/

#include <windows.h>
#include <string.h>

UINT ClobalRepair (PTSTRpText,UINTiText,LPWSTRpTextU,UINTiTextU)
{
    const PTSTR  tZ= "//uinput2//u",
                          tA = "//cf0//par",
                          tP = "//par";
    TCHAR           AnsiT[11];
    PTSTR            pTextS  = pText,
                          pTextW  = NULL,
                          pAnsiT  = AnsiT;
    PTCHAR          pTextK  = NULL;
    UINT               i,iU,iC = 0,iR= 0,
                         UTRange = 10;
    BOOL            bAnsi=FALSE;
    LPWSTR        pTextUW = pTextU;
    long int         iM;

    while(TRUE)
    {
        // 查找/uinput2/u
        pTextS =strstr(pTextS,tZ);
        if(pTextS==NULL)
            break;
        // 指向Unicode編碼的首字節
        pTextS =&pTextS[UTRange];
        // 獲取Unicode編碼的十六進制值
        iM =strtol(pTextS,&pTextK,10);
        // 修正負數補碼的問題
        iM =iM& 0xFFFF;

        pTextS =pTextK;
        pTextS =&pTextS[1];
        pTextS[0]=' ';
        pTextS =&pTextS[1];

        // 在Unicode數據中對焦中文字符
        for (iU=0; iU < iTextU;iU++)
        {
            if(pTextUW[iU]==iM)
            {
                pTextUW = &pTextUW[iU+1];
                iTextU -= (iU+1);
                break;
            }
        }

        // 中文接中文的處理
        if (pTextUW[0]>0x80)
        {
            pTextW = strstr(pTextS,tZ);
            iC =pTextW- pTextS;
            i  =pTextS- pText;
            iR =i+ iC;
            for (i=0; iR <= iText;i++,iR++)
                pTextS[i]=pTextW[i];
            iText -= iC;
            continue;
        }
        // 文檔尾的處理
        if(pTextUW[0]==NULL)
        {
            pTextW = strstr(pTextS,tP);
            iC =pTextW- pTextS;
            i  =pTextS- pText;
            iR =i+ iC;
            for (i=0; iR <= iText;i++,iR++)
                pTextS[i]=pTextW[i];
            iText -= iC;
            continue;
        }
        // 換行符、回車及水平製表
        if (pTextUW[0]==0x0D || pTextUW[0]==0x09)
        {
            pTextW = strstr(pTextS,tA);
            iC =pTextW- pTextS;
            i  =pTextS- pText;
            iR =i+ iC;
            for (i=0; iR <= iText;i++,iR++)
                pTextS[i]=pTextW[i];
            iText -= iC;
            continue;
        }
        // 中文接ASCII的處理
        if (pTextUW[0]<=0x80 && pTextUW[0]>=0x20)
        {
            for (i=0; i < 11;i++)
                AnsiT[i]=NULL;
            pAnsiT  = AnsiT;
            for (iR=0; iR < 4&& ((pTextUW[iR]<=0x80) && (pTextUW[iR]>=0x20)); iR++)
            {
                if (pTextUW[iR]==0x5C || pTextUW[iR]==0x7B || pTextUW[iR]==0x7D)
                {
                    pAnsiT[0]='//';
                    pAnsiT    = &pAnsiT[1];
                    pAnsiT[0]=pTextUW[iR];
                    pAnsiT    = &pAnsiT[1];
                }
                else
                {
                    pAnsiT[0]=pTextUW[iR];
                    pAnsiT    = &pAnsiT[1];
                }
            }
            if (strlen(AnsiT)<=3)
                AnsiT[iR]='//';

            pTextW = pTextS;
            pTextW = strstr(pTextS,AnsiT);
            if(pTextW==NULL)
            {
                bAnsi = FALSE;
                pTextW = pTextS;
                for (iC=0; TRUE; iC++)
                {
                    if ((pTextW[iC]=='//' && pTextW[iC-1]!='//') &&
                        (pTextW[iC+1]=='c' || pTextW[iC+1]=='p')  &&
                        (pTextW[iC+2]=='f' || pTextW[iC+2]=='a')  &&
                        (pTextW[iC+3]=='0' || pTextW[iC+3]=='r'))
                    {
                        pTextW = &pTextW[iC];
                        break;
                    }
                }

                while(TRUE)
                {
                    if (pTextW[0]==AnsiT[0])
                    {
                        if (AnsiT[0]=='//')
                        {
                            if (pTextW[1]==AnsiT[1])
                                break;
                        }
                        else
                        {
                            if (AnsiT[1]!=NULL && pTextW[1]==AnsiT[1])
                                break;
                            else
                            {
                                if(pTextW[1]=='//' &&
                                  (pTextW[2]=='c'|| pTextW[2]=='p') &&
                                  (pTextW[3]=='f'|| pTextW[3]=='a'))
                                {
                                  bAnsi = TRUE;
                                  break;
                                }
                            }
                        }
                    }
                    pTextW = &pTextW[-1];
                }

                if (AnsiT[2]!=NULL && bAnsi !=TRUE)
                {
                    while(TRUE)
                    {
                        if (pTextW[0]==AnsiT[0]&&pTextW[1]==AnsiT[1]&&
                            pTextW[2]==AnsiT[2])
                        {
                            if (AnsiT[2]=='//')
                            {
                                if (pTextW[3]==AnsiT[3])
                                    break;
                            }
                            else
                            {
                                if (AnsiT[3]!=NULL && pTextW[3]==AnsiT[3])
                                    break;
                                else
                                {
                                    if  (pTextW[3]=='//' &&
                                        (pTextW[4]=='c' || pTextW[4]=='p') &&
                                        (pTextW[5]=='f' || pTextW[5]=='a'))
                                    {
                                        bAnsi = TRUE;
                                        break;
                                    }
                                }
                            }
                        }
                        pTextW = &pTextW[-1];                       
                    }
                }

                if (AnsiT[3]!=NULL && bAnsi !=TRUE)
                {
                    while(TRUE)
                    {
                        if (pTextW[0]==AnsiT[0]&&pTextW[1]==AnsiT[1]&&
                            pTextW[2]==AnsiT[2]&&pTextW[3]==AnsiT[3])
                        {
                            if (AnsiT[3]=='//')
                            {
                                if (pTextW[4]==AnsiT[4])
                                    break;
                            }
                            else
                            {
                                if (AnsiT[4]!=NULL && pTextW[4]==AnsiT[4])
                                    break;
                                else
                                {
                                    if  (pTextW[4]=='//' &&
                                        (pTextW[5]=='c' || pTextW[5]=='p') &&
                                        (pTextW[6]=='f' || pTextW[6]=='a'))
                                    {
                                        bAnsi = TRUE;
                                        break;
                                    }
                                }
                            }
                        }
                        pTextW = &pTextW[-1];                       
                    }
                }

                if (AnsiT[4]!=NULL && bAnsi !=TRUE)
                {
                    while(TRUE)
                    {
                        if (pTextW[0]==AnsiT[0]&&pTextW[1]==AnsiT[1]&&
                            pTextW[2]==AnsiT[2]&&pTextW[3]==AnsiT[3]&&
                            pTextW[4]==AnsiT[4])
                        {
                            if (AnsiT[4]=='//')
                            {
                                if (pTextW[5]==AnsiT[5])
                                    break;
                            }
                            else
                            {
                                if (AnsiT[5]!=NULL && pTextW[5]==AnsiT[5])
                                    break;
                                else
                                {
                                    if  (pTextW[5]=='//' &&
                                        (pTextW[6]=='c' || pTextW[6]=='p') &&
                                        (pTextW[7]=='f' || pTextW[7]=='a'))
                                    {
                                        bAnsi = TRUE;
                                        break;
                                    }
                                }
                            }
                        }
                        pTextW = &pTextW[-1];                       
                    }
                }

                if (AnsiT[5]!=NULL && bAnsi !=TRUE)
                {
                    while(TRUE)
                    {
                        if (pTextW[0]==AnsiT[0]&&pTextW[1]==AnsiT[1]&&
                            pTextW[2]==AnsiT[2]&&pTextW[3]==AnsiT[3]&&
                            pTextW[4]==AnsiT[4]&&pTextW[5]==AnsiT[5])
                        {
                            if (AnsiT[5]=='//')
                            {
                                if (pTextW[6]==AnsiT[6])
                                    break;
                            }
                            else
                            {
                                if (AnsiT[6]!=NULL && pTextW[6]==AnsiT[6])
                                    break;
                                else
                                {
                                    if  (pTextW[6]=='//' &&
                                        (pTextW[7]=='c' || pTextW[7]=='p') &&
                                        (pTextW[8]=='f' || pTextW[8]=='a'))
                                    {
                                        bAnsi = TRUE;
                                        break;
                                    }
                                }
                            }
                        }
                        pTextW = &pTextW[-1];                       
                    }
                }

                if (AnsiT[6]!=NULL && bAnsi !=TRUE)
                {
                    while(TRUE)
                    {
                        if (pTextW[0]==AnsiT[0]&&pTextW[1]==AnsiT[1]&&
                            pTextW[2]==AnsiT[2]&&pTextW[3]==AnsiT[3]&&
                            pTextW[4]==AnsiT[4]&&pTextW[5]==AnsiT[5]&&
                            pTextW[6]==AnsiT[6] )
                        {
                            if (AnsiT[6]=='//')
                            {
                                if (pTextW[7]==AnsiT[7])
                                    break;
                            }
                            else
                            {
                                if (AnsiT[7]!=NULL && pTextW[7]==AnsiT[7])
                                    break;
                                else
                                {
                                    if  (pTextW[7]=='//' &&
                                        (pTextW[8]=='c' || pTextW[8]=='p') &&
                                        (pTextW[9]=='f' || pTextW[9]=='a'))
                                    {
                                        bAnsi = TRUE;
                                        break;
                                    }
                                }
                            }
                        }
                        pTextW = &pTextW[-1];                       
                    }
                }

                if (AnsiT[7]!=NULL && bAnsi !=TRUE)
                {
                    while(TRUE)
                    {
                        if (pTextW[0]==AnsiT[0]&&pTextW[1]==AnsiT[1]&&
                            pTextW[2]==AnsiT[2]&&pTextW[3]==AnsiT[3]&&
                            pTextW[4]==AnsiT[4]&&pTextW[5]==AnsiT[5]&&
                            pTextW[6]==AnsiT[6]&&pTextW[7]==AnsiT[7])
                        {
                            if (AnsiT[7]=='//')
                            {
                                if (pTextW[8]==AnsiT[8])
                                    break;
                            }
                            else
                            {
                                if (AnsiT[8]!=NULL && pTextW[8]==AnsiT[8])
                                    break;
                                else
                                {
                                    if  (pTextW[8]=='//' &&
                                        (pTextW[9]=='c' || pTextW[9]=='p') &&
                                        (pTextW[10]=='f' || pTextW[10]=='a'))
                                    {
                                        bAnsi = TRUE;
                                        break;
                                    }
                                }
                            }
                        }
                        pTextW = &pTextW[-1];                       
                    }
                }
            }

            iC =pTextW- pTextS;
            i  =pTextS- pText;
            iR =i+ iC;
            for (i=0; iR <= iText;i++,iR++)
                pTextS[i]=pTextW[i];
            iText -= iC;
            continue;
        }
    }
    return iText;
}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

iLogtail 2.0 重大升級，端上支持 SPL

作者：太業 流式處理語言發展 早期流式處理概念： 20 世紀 70 年代，編程語言如 APL 提供了對數組的流式操作，這可以看作是流式處理語法的早期形式。 管道（Pipes）概念在 UNIX 系統中的引進使得可以通過命令行將一個命令的

原創 2024-06-05 21:13:43

看不懂正則表達式？試試可視化工具吧！

1. 前言 正則表達式是一種用來匹配字符串的強有力工具。設計思想是用一種描述性的語言來給字符串定義一個規則，凡是符合規則的字符串我們就認爲它“匹配”了，否則該字符串就是不合法的。 日常開發中常常會使用正則表達式，例如：對數據格式進行校

原創 2024-05-24 23:57:40

「Qt Widget中文示例指南」如何實現一個簡單的RHI小部件示例（二）

Qt 是目前最先進、最完整的跨平臺C++開發工具。它不僅完全實現了一次編寫，所有平臺無差別運行，更提供了幾乎所有開發過程中需要用到的工具。如今，Qt已被運用於超過70個行業、數千家企業，支持數百萬設備及應用。 本文將爲大家演示如何使用QRh

原創 2024-06-05 12:16:38

「盤點」JetBrains IDEs v2024.1新功能一覽，更智能的開發體驗！

JetBrains IDEs日前正式發佈了v2024.1版本，此版本中最大的亮點就是帶來了AI賦能的全行代碼補全，同時在最新的IDEs中重做了終端、擁有更強大的代碼編輯和導航功能、更智能的代碼分析和提示、更優化的性能、更豐富的插件和集成等。

原創 2024-05-29 12:18:44

昔日輝煌不再，PHP老矣，尚能飯否？

導語 | 近期 TIOBE 最新指數顯示，PHP 的流行度降至了歷史最低，排在第 17 名，同時，在年度 Stack Overflow 開發者調查報告中，PHP 在開發者中的受歡迎程度已經從之前的約 30% 萎縮至現在的 18%。“P

原創 2024-05-23 23:48:42

實現“代碼可視化”需要了解的前置知識-編譯器中端

1. 前言 前文實現“代碼可視化”需要了解的前置知識-編譯器前端介紹了編譯器前端知識並附帶了小練習，本文將繼續介紹編譯器中端相關的知識，還是概念+練習的學習方式。中間代碼是用來進行程序分析和實現代碼可視化的關鍵數據，瞭解其生成和優化方式能

原創 2024-05-21 11:56:05

跨端自渲染繪製的實踐與探索

在過去的大半年中，我一直投身於一個跨端自渲染項目的研發工作中，負責其中的渲染模塊。現在通過這篇文章，我想記錄並分享我們在這個項目中的經驗和挑戰，希望能爲大家日常開發中的涉及到渲染相關的工作帶來一些啓發和幫助。 跨端自渲染的初衷 跨端自

原創 2024-05-21 11:56:03

一文搞懂 Spring 循環依賴

這個其實是一個特別高頻的面試題，松哥也一直很想和大家仔細來聊一聊這個話題，網上關於這塊的文章很多，但是我一直覺得要把這個問題講清楚還有點難度，今天我來試一試，看能不能和小夥伴們把這個問題梳理清楚，當然，如果小夥伴們覺得看文章不過癮，松哥也有

原創 2024-06-06 13:11:47

8個實用的Java Streams API

分享8個開箱即用的API，方便日常處理集合。 1. 快速過濾空值：Stream.ofNullable 該方法是在 Java 9 中引入的，有助於過濾集合中的所有空值，從而可能使我們避免空指針異常。 在下面的示例中，有一個包含 null 的L

原創 2024-06-04 21:46:09

記一次疑似JVM內存泄漏的排查過程

一、背景 在日常部門OpsReview過程中，部門內多次遇到應用容器所在的宿主機磁盤繁忙導致的接口響應緩慢，TP99增高等影響服務性能的問題，其中比較有效的解決方案是開啓日誌的異步打印，可以有效避免同步日誌打印在磁盤IO高起的情況下拖慢業

原創 2024-06-04 12:09:32

淺析MySQL 8.0直方圖原理

本文分享自華爲雲社區《【MySQL技術專欄】MySQL8.0直方圖介紹》，作者：GaussDB 數據庫。 背景 數據庫查詢優化器負責將SQL查詢轉換爲儘可能高效的執行計劃，但因爲數據環境不斷變化導致優化器對查詢數據瞭解的不夠充足，可能無法

原創 2024-05-27 10:58:41

聊聊Spring中的數據綁定 --- WebDataBinder、ServletRequestDataBinder、WebBindingInitializer 文章源於Ai生成

每篇一句 大魔王張怡寧：女兒，這堆金牌你拿去玩吧，但我的銀牌不能給你玩。你要想玩銀牌就去找你王浩叔叔吧，他那銀牌多 前言 爲了講述好Spring MVC最爲複雜的數據綁定這塊，我前面可謂是做足了功課，對此部分知識此處給小夥伴留一個學

微學網絡 2024-05-27 10:53:57

分佈式任務調度內的 MySQL 分頁查詢優化

作者：vivo 互聯網數據庫團隊- Qiu Xinbo 本文主要通過圖示介紹了用主鍵進行分片查詢的過程，介紹了主鍵分頁查詢存在SQL性能問題，如何去創建高效的索引去優化主鍵分頁查詢的SQL性能問題 對於數據分佈不均

原創 2024-05-24 12:09:18

Java常用的JSON序列化與反序列化工具實踐

JSON簡介： JSON（Java Script Object Notation）是一種輕量級的數據交換格式，通常用於在不同系統之間傳輸數據。它基於 JavaScript 對象語法，但已成爲一種獨立於語言的格式。JSON 數據以鍵值對的形式

原創 2024-05-20 23:55:38

由淺入深在實踐中玩轉Zabbix，解決剩下20%的監控需求！

本文整理自Zabbix中級認證專家李銘栓（滿分學員）在Zabbix Meetup廣州站的演講。 掌握這幾種監控方式解決80%的監控問題，剩下的20%如何實現？這裏有答案！ 幾點經驗分享： 1

Zabbix中國 2024-05-24 22:33:53