{-------------------------------
[半角80桁で折返し]の
処理を行う。
EmEditorのプラグインDLLです
履歴
2006/04/22 Ver1.0
・  作成
2006/04/23 0:34 Ver1.1
・  設定ファイルを読み込む形式に改造した
2006/04/23(日) 14:57   Ver1.2
・ 行末/行頭の連続処理に誤動作があったので修正
--------------------------------}
library WordWrap;

{$R 'WordWrap.res' 'WordWrap.rc'}

uses
  SysUtils,
  Windows,
  WideStringRecordList,
  StringUnitLight,
  FileUnit,
  XPtest,
  PluginLibrary,
  plugin;

////////////////////////////////////////////////////////////
{$define constValue}
{$include PluginBaseInclude.pas}
////////////////////////////////////////////////////////////

{-------------------------------
//  TabToSpace
機能:       タブをスペースに置き換える関数
引数説明:   S: 変換する文字列
戻り値:     変換後の文字列
備考:       タブは4スペースに変換されるとしている
履歴:       2002/08/31
//------------------------------}
function TabToSpaceLineWStr(const S: WideString): WideString;
var
  ReadIndex: Integer;
  OutputIndex: Integer;
  SourceLen: Integer;
  TabReplaceSpaceCount: Integer;
  i: Integer;
const
  TabToSpaceOptionCount = 4;
begin
  Result := '';
  if S = '' then Exit;

  SourceLen := Length(S);
  SetLength(Result, SourceLen * 4);

  ReadIndex := 1;
  OutputIndex := 1;

  while (ReadIndex <= SourceLen) do
  begin
    if (S[ReadIndex] = #9) then
    begin
      TabReplaceSpaceCount := TabToSpaceOptionCount - ( CharToByteLen(Result, (OutputIndex-1)) mod TabToSpaceOptionCount );
      for i:=0 to TabReplaceSpaceCount-1 do
      begin
        Result[OutputIndex+i] := ' ';
      end;
      Inc(OutputIndex, TabReplaceSpaceCount);
      Inc(ReadIndex);
    end else
    begin
      Result[OutputIndex] := S[ReadIndex];
      Inc(OutputIndex);
      Inc(ReadIndex);
    end;
  end; //while
  SetLength(Result, OutputIndex-1);
end;

function TabToSpace(const S: WideString): WideString;
var
  StrList: TWideStringRecordList;
  i: Integer;
begin
  StrList := TWideStringRecordList.Create;
  try
    StrList.Text := S;
    for i:=0 to StrList.Count-1 do
    begin
      StrList.Items[i] := TabToSpaceLineWStr(StrList.Items[i]);
    end;

    Result := StrList.Text;

  finally
    StrList.Free;
  end;
end;
//------------------------------

{-------------------------------
//  文字列を折り返します
機能:       80桁(半角)で折り返したりすることができます。
            WrapCtrlで半角/全角英単語禁則、日本語行末/行頭禁則処理を
            ON/OFFすることができる。
備考:         TextはCRLFで改行されているという前提の下で処理を行ってます
            uses StringUnitLightが必要
            タブには対応してないので
            TabToSpaceを利用してからこの関数に渡すといい
            文字列整形の場合、80桁でWrapしてから70桁でWrapすると
            10桁分が変になるので、DeleteTextLineCRLFを使ってから
            TextWordWrapを行うとよいだろう。
履歴:       2006/04/22
              作成
            2006/04/23
              行頭/行末禁則の連続処理に誤動作があったので処理順等を
              変更して改善した
            2006/05/13
            ・半角カナに対応していなかったのでWideCharByteLengthの
              実装を変更した
//------------------------------}

//禁則処理を入れるかどうかを制御している
type TWrapProcess = (wpEnglishWordWrap, wpEnglishDoubleByteWordWrap,
                     wpJapaneseLineEndWrap, wpJapaneseLineHeadWrap);
//wcJapaneseLineEndWrap:        行末禁則
//wcJapaneseLineHeadWrap:       行頭禁則
//wcEnglishWordWrap:            単語禁則
//wcEnglishDoubleByteWordWrap:  全角英単語禁則
type TWrapProcesses = set of TWrapProcess;

//行末禁則
const JapaneseLineEndWrap: WideString =
    '([{｢''"' +
    '（［｛「〔《『【〈≪‘“';

//行頭禁則
const JapaneseLineHeadWrap: WideString =
    '､｡,.?!ﾞﾟ~''")]}｣ｰｧｨｩｪｫｯｬｭｮ'+
    '、。，．？！゛゜〜…‥’”）〕］｝〉》」』】≫ーぁぃぅぇぉっゃゅょァィゥェォッャュョ';

//折返し処理の本体
function TextWordWrap(Text: WideString; WrapByteCount: Integer;
 WrapCtrl: TWrapProcesses): WideString;

const WrapStr: String = CRLF;

    procedure InsertAdd(StrList: TWideStringRecordList; Index: Integer;
      InsertAddLineStr: String);
    begin
      if Index = StrList.Count then
      begin
        StrList.Add(InsertAddLineStr);
      end else
      begin
        StrList.Insert(Index, InsertAddLineStr);
      end;
    end;

    procedure LineWrap(StrList: TWideStringRecordList;
     LineIndex, WrapCharIndex: Integer);
    begin
      InsertAdd(StrList, LineIndex+1,
        Copy(StrList.Items[LineIndex],
          WrapCharIndex, MaxInt) );
      {↑折り返して行を挿入している}
      StrList.Items[LineIndex] :=
        Copy(StrList.Items[LineIndex], 1,
          WrapCharIndex-1) + WrapStr;
    end;

    //前方探索してテーブルに含まれていない文字の場所を見つけて返す関数
    //行末禁則などの改行位置を求めるために使う
    function ForwardSearchNoWrapChar(LineText, Table: WideString;
     StartPoint: Integer): Integer;
    var
      i: Integer;
      j: Integer;
    begin
      Result := 0;
      if (StartPoint <= 0) or (Length(LineText)< StartPoint) then Exit;

      for i := StartPoint downto 1 do
      begin
        if not CheckWideCharInTable(LineText[i], Table) then
        begin
          Result := i;
          break;
        end;
      end;
    end;

var
  StrRecList: TWideStringRecordList;
  i: Integer;
//  WrapByteIndex: Integer;
  WrapCharIndex: Integer;
  CheckWrapLineEndChar: WideChar;
  SearchWrapIndex: Integer;
begin
  if not(1<=WrapByteCount) then
    raise Exception.Create('WrapByteCount='+IntToStr(WrapByteCount)+CRLF+
                           'WrapByteCountが負の値です');

  StrRecList := TWideStringRecordList.Create; try
  StrRecList.Text := Text;

  i := 0;
  while i <= (StrRecList.Count - 1) do
  begin
    if WrapByteCount < ByteLength(TrimRightChar(StrRecList.Items[i], CRLF)) then
    begin
      WrapCharIndex := ByteIndexToCharIndex(StrRecList.Items[i], WrapByteCount+1);
      //折返しが80桁(WrapByteCount=80)ならWrapCharIndexは81Byte目の文字位置=CharIndex

      {↓折返し位置が2文字以下なら禁則処理をしない
         2文字目が折返しなら必ず折り返す。(ありえないけど...)}
      if 2 = WrapCharIndex then
      begin
        LineWrap(StrRecList, i, WrapCharIndex);
      end else
      if 3 <= WrapCharIndex then
      begin
        if WrapCtrl = [] then
        begin

        end;

        {↓もしWrapCharIndexの位置の1文字が行頭禁則文字で
           行頭禁則Wrapモードが含まれている場合}
        if CheckWideCharInTable(Copy(StrRecList[i], WrapCharIndex, 1)[1], JapaneseLineHeadWrap)
          and (wpJapaneseLineHeadWrap in WrapCtrl) then
        begin
          {前方探索して行頭禁則文字がない場所をみつけて}
          {その文字位置で改行}
          SearchWrapIndex :=
            ForwardSearchNoWrapChar(StrRecList[i], JapaneseLineHeadWrap, WrapCharIndex-1);
          if SearchWrapIndex<>0 then
          begin
            WrapCharIndex := SearchWrapIndex;
          end;
        end;

        {↓もしWrapCharIndexの位置の1文字が英語数字で
           英語WordWrapモードが含まれている場合}
        if CheckWideCharInTable(Copy(StrRecList[i], WrapCharIndex, 1)[1], hanAlphaTbl+hanNumberTbl)
          and (wpEnglishWordWrap in WrapCtrl) then
        begin
          {前方探索して英語数字がない場所を見つけて}
          {その文字位置+1の位置で改行}
          SearchWrapIndex :=
            ForwardSearchNoWrapChar(StrRecList[i], hanAlphaTbl+hanNumberTbl, WrapCharIndex-1);
          if SearchWrapIndex<>0 then
          begin
            WrapCharIndex := SearchWrapIndex + 1;
          end;
        end;

        {↓上記半角英数字WordWrapと同様}
        if CheckWideCharInTable(Copy(StrRecList[i], WrapCharIndex, 1)[1], zenAlphaTbl+zenNumberTbl)
          and (wpEnglishWordWrap in WrapCtrl) then
        begin
          SearchWrapIndex :=
            ForwardSearchNoWrapChar(StrRecList[i], zenAlphaTbl+zenNumberTbl, WrapCharIndex-1);
          if SearchWrapIndex<>0 then
          begin
            WrapCharIndex := SearchWrapIndex + 1;
          end;
        end;

        {↓もしWrapCharIndex-1の位置の1文字が行末禁則文字で
           行末禁則Wrapモードが含まれている場合}
        if CheckWideCharInTable(Copy(StrRecList[i], WrapCharIndex-1, 1)[1], JapaneseLineEndWrap)
          and (wpJapaneseLineEndWrap in WrapCtrl) then
        begin
          {前方探索して行末禁則文字がない場所をみつけて}
          {その文字位置+1の位置で改行}
          SearchWrapIndex :=
            ForwardSearchNoWrapChar(StrRecList[i], JapaneseLineEndWrap, WrapCharIndex-2);
          if SearchWrapIndex<>0 then
          begin
            WrapCharIndex := SearchWrapIndex + 1;
          end;
        end;

        LineWrap(StrRecList, i, WrapCharIndex);
      end;

    end;
    Inc(i);
  end;
  Result := StrRecList.Text;
  finally StrRecList.Free; end;
end;

procedure testTextWordWrap;
begin
  {↓禁則がない場合の折り返し処理}
  Check('123',
    TextWordWrap('123', 3, []));
  Check('123'+CRLF,
    TextWordWrap('123'+CRLF, 3, []));
  Check('123'+CRLF+'456'+CRLF+'78',
    TextWordWrap('12345678', 3, []));
  Check('123'+CRLF+'456'+CRLF+'789',
    TextWordWrap('123456789', 3, []));
  Check('123'+CRLF+'456'+CRLF+'789'+CRLF,
    TextWordWrap('123456789'+CRLF, 3, []));
  Check('123'+CRLF+'45'+CRLF+'678'+CRLF+'9',
    TextWordWrap('12345'+CRLF+'6789', 3, []));
  Check('123'+CRLF+'45'+CRLF+'678'+CRLF+'9AB',
    TextWordWrap('12345'+CRLF+'6789AB', 3, []));
  Check('123'+CRLF+'45'+CRLF+'678'+CRLF+'9AB'+CRLF,
    TextWordWrap('12345'+CRLF+'6789AB'+CRLF, 3, []));
  Check('1あ'+CRLF+'45'+CRLF+'い8',
    TextWordWrap('1あ45い8', 3, []));
  Check('1あ'+CRLF+'45'+CRLF+'い8'+CRLF+'9',
    TextWordWrap('1あ45い89', 3, []));
  Check('1あ'+CRLF+'45'+CRLF+'い8'+CRLF+'9'+CRLF,
    TextWordWrap('1あ45い89'+CRLF, 3, []));
  Check('あ3'+CRLF+'45'+CRLF+'67'+CRLF+'い',
    TextWordWrap('あ345'+CRLF+'67い', 3, []));
  Check('1あ'+CRLF+'い'+CRLF+'う'+CRLF+'6お'+CRLF+'78'+CRLF+'か9',
    TextWordWrap('1あいう'+CRLF+'6お78か9', 3, []));
  Check('1あ'+CRLF+'い'+CRLF+'う'+CRLF+'6お'+CRLF+'78'+CRLF+'か9'+CRLF,
    TextWordWrap('1あいう'+CRLF+'6お78か9'+CRLF, 3, []));
  Check('12345'+CRLF+'678',
    TextWordWrap('12345678', 5, []));
  Check('12345'+CRLF+'67890',
    TextWordWrap('1234567890', 5, []));
  Check('12345'+CRLF+'67890'+CRLF,
    TextWordWrap('1234567890'+CRLF, 5, []));
  Check('12345'+CRLF+'6789',
    TextWordWrap('12345'+CRLF+'6789', 5, []));
  Check('123'+CRLF+'45'+CRLF+'6789A'+CRLF+'B',
    TextWordWrap('123'+CRLF+'45'+CRLF+'6789AB', 5, []));
  Check('12345'+CRLF+'6789AB'+CRLF,
    TextWordWrap('12345'+CRLF+'6789AB'+CRLF, 6, []));
  Check('1あ4'+CRLF+'5い8',
    TextWordWrap('1あ45い8', 4, []));
  Check('1'+CRLF+'あ'+CRLF+'45'+CRLF+'い'+CRLF+'89',
    TextWordWrap('1あ45い89', 2, []));
  Check('1あ4'+CRLF+'5い8'+CRLF+'9'+CRLF,
    TextWordWrap('1あ45い89'+CRLF, 4, []));
  Check('あ345'+CRLF+'67い',
    TextWordWrap('あ345'+CRLF+'67い', 6, []));
  Check('1あい'+CRLF+'う'+CRLF+'6お78'+CRLF+'か9',
    TextWordWrap('1あいう'+CRLF+'6お78か9', 6, []));
  Check('1あ'+CRLF+'いう'+CRLF+'6お7'+CRLF+'8か9'+CRLF,
    TextWordWrap('1あいう'+CRLF+'6お78か9'+CRLF, 4, []));

  {↓英単語禁則の処理}
  Check('あいうえお'+CRLF+'ABC',
    TextWordWrap('あいうえおABC', 10, []));
  Check('あいうえおA'+CRLF+'BC',
    TextWordWrap('あいうえおABC', 11, []));
  Check('あいうえおAB'+CRLF+'C',
    TextWordWrap('あいうえおABC', 12, []));
  Check('あいうえおABC',
    TextWordWrap('あいうえおABC', 13, []));
  Check('あいうえお'+CRLF+'ABC',
    TextWordWrap('あいうえおABC', 12, [wpEnglishWordWrap]));
  Check('あいうえお'+CRLF+'ABC'+CRLF,
    TextWordWrap('あいうえおABC'+CRLF, 10, [wpEnglishWordWrap]));
  Check('あいうえお'+CRLF+'ABC'+CRLF,
    TextWordWrap('あいうえおABC'+CRLF, 12, [wpEnglishWordWrap]));
  Check('あいうえおABC',
    TextWordWrap('あいうえおABC', 13, [wpEnglishWordWrap]));
  Check('あいうえおABC'+CRLF,
    TextWordWrap('あいうえおABC'+CRLF, 13, [wpEnglishWordWrap]));
  Check('あい'+CRLF+'うえ'+CRLF+'お'+CRLF+'ABCDE'+CRLF+'F'+CRLF,
    TextWordWrap('あいうえおABCDEF'+CRLF, 5, [wpEnglishWordWrap]));
  Check('あい'+CRLF+'うえ'+CRLF+'おABC'+CRLF+'DEF'+CRLF,
    TextWordWrap('あいうえおABCDEF'+CRLF, 5, []));

  {↓行頭禁則の処理}
  Check('あいうえお))))'+CRLF+')',
    TextWordWrap('あいうえお)))))', 14, []));
  Check('あいうえお))))'+CRLF+')',
    TextWordWrap('あいうえお)))))', 14, [wpEnglishWordWrap, wpEnglishDoubleByteWordWrap, wpJapaneseLineEndWrap]));
  Check('あいうえ'+CRLF+'お)))))',
    TextWordWrap('あいうえお)))))', 14, [wpJapaneseLineHeadWrap]));
  Check('))))))))))))))'+CRLF+')',
    TextWordWrap(')))))))))))))))', 14, []));
  Check('))))))))))))))'+CRLF+')',
    TextWordWrap(')))))))))))))))', 14, [wpJapaneseLineEndWrap]));
  Check('))))))))))))))'+CRLF+')',
    TextWordWrap(')))))))))))))))', 14, [wpJapaneseLineHeadWrap]));

  {↓行末禁則の処理}
  Check('あいうえお(((('+CRLF+'(',
    TextWordWrap('あいうえお(((((', 14, []));
  Check('あいうえお(((('+CRLF+'(',
    TextWordWrap('あいうえお(((((', 14, [wpEnglishWordWrap, wpEnglishDoubleByteWordWrap, wpJapaneseLineHeadWrap]));
  Check('あいうえお'+CRLF+'(((((',
    TextWordWrap('あいうえお(((((', 14, [wpJapaneseLineEndWrap]));
  Check('(((((((((((((('+CRLF+'(',
    TextWordWrap('(((((((((((((((', 14, []));
  Check('(((((((((((((('+CRLF+'(',
    TextWordWrap('(((((((((((((((', 14, [wpJapaneseLineHeadWrap]));
  Check('(((((((((((((('+CRLF+'(',
    TextWordWrap('(((((((((((((((', 14, [wpJapaneseLineEndWrap]));

(*-----------------------------------
[(((())))]の場合[改行][(((())))]という形式になるべきだし
 ↑行末禁則/行頭禁則の順
[))))((((]の場合[))))][改行][((((]となるべき
 ↑行頭禁則/行末禁則の順
//-----------------------------------*)

  {↓行末-行頭禁則}
  Check(            'あいうえお(((('+CRLF+'()))))',
    TextWordWrap(   'あいうえお((((()))))', 14, []));
  Check(            'あいうえお(((('+CRLF+'()))))',
    TextWordWrap(   'あいうえお((((()))))', 14, [wpJapaneseLineHeadWrap]));
  Check(            'あいうえお'+CRLF+'((((()))))',
    TextWordWrap(   'あいうえお((((()))))', 14, [wpJapaneseLineEndWrap]));
  Check(            'あいうえお'+CRLF+'((((()))))',
    TextWordWrap(   'あいうえお((((()))))', 14, [wpJapaneseLineEndWrap, wpJapaneseLineHeadWrap]));
  Check(            'あいうえお((((())))'+CRLF+')',
    TextWordWrap(   'あいうえお((((()))))', 19, []));
  Check(            'あいうえお(((('+CRLF+'()))))',
    TextWordWrap(   'あいうえお((((()))))', 19, [wpJapaneseLineHeadWrap]));
  Check(            'あいうえお((((())))'+CRLF+')',
    TextWordWrap(   'あいうえお((((()))))', 19, [wpJapaneseLineEndWrap]));
  Check(            'あいうえお'+CRLF+'((((()))))',
    TextWordWrap(   'あいうえお((((()))))', 19, [wpJapaneseLineEndWrap, wpJapaneseLineHeadWrap]));
  Check(            '((((()))))(((('+CRLF+'()))))',
    TextWordWrap(   '((((()))))((((()))))', 14, []));
  Check(            '((((()))))(((('+CRLF+'()))))',
    TextWordWrap(   '((((()))))((((()))))', 14, [wpJapaneseLineHeadWrap]));
  Check(            '((((()))))'+CRLF+'((((()))))',
    TextWordWrap(   '((((()))))((((()))))', 14, [wpJapaneseLineEndWrap]));
  Check(            '((((()))))'+CRLF+'((((()))))',
    TextWordWrap(   '((((()))))((((()))))', 14, [wpJapaneseLineEndWrap, wpJapaneseLineHeadWrap]));
  Check(            '((((()))))((((())))'+CRLF+')',
    TextWordWrap(   '((((()))))((((()))))', 19, []));
  Check(            '((((()))))(((('+CRLF+'()))))',
    TextWordWrap(   '((((()))))((((()))))', 19, [wpJapaneseLineHeadWrap]));
  Check(            '((((()))))((((())))'+CRLF+')',
    TextWordWrap(   '((((()))))((((()))))', 19, [wpJapaneseLineEndWrap]));
  Check(            '((((()))))'+CRLF+'((((()))))',
    TextWordWrap(   '((((()))))((((()))))', 19, [wpJapaneseLineEndWrap, wpJapaneseLineHeadWrap]));

  {↓行頭-行末禁則}
  Check(            'あいうえお))))'+CRLF+')(((((',
    TextWordWrap(   'あいうえお)))))(((((', 14, []));
  Check(            'あいうえ'+CRLF+'お)))))(((((',
    TextWordWrap(   'あいうえお)))))(((((', 14, [wpJapaneseLineHeadWrap]));
  Check(            'あいうえお))))'+CRLF+')(((((',
    TextWordWrap(   'あいうえお)))))(((((', 14, [wpJapaneseLineEndWrap]));
  Check(            'あいうえ'+CRLF+'お)))))(((((',
    TextWordWrap(   'あいうえお)))))(((((', 14, [wpJapaneseLineEndWrap, wpJapaneseLineHeadWrap]));
  Check(            'あいうえお)))))(((('+CRLF+'(',
    TextWordWrap(   'あいうえお)))))(((((', 19, []));
  Check(            'あいうえお)))))(((('+CRLF+'(',
    TextWordWrap(   'あいうえお)))))(((((', 19, [wpJapaneseLineHeadWrap]));
  Check(            'あいうえお)))))'+CRLF+'(((((',
    TextWordWrap(   'あいうえお)))))(((((', 19, [wpJapaneseLineEndWrap]));
  Check(            'あいうえお)))))'+CRLF+'(((((',
    TextWordWrap(   'あいうえお)))))(((((', 19, [wpJapaneseLineEndWrap, wpJapaneseLineHeadWrap]));
  Check(            ')))))((((())))'+CRLF+')(((((',
    TextWordWrap(   ')))))((((()))))(((((', 14, []));
  Check(            ')))))(((('+CRLF+'()))))(((((',
    TextWordWrap(   ')))))((((()))))(((((', 14, [wpJapaneseLineHeadWrap]));
  Check(            ')))))((((())))'+CRLF+')(((((',
    TextWordWrap(   ')))))((((()))))(((((', 14, [wpJapaneseLineEndWrap]));
  Check(            ')))))'+CRLF+'((((()))))'+CRLF+'(((((',
    TextWordWrap(   ')))))((((()))))(((((', 14, [wpJapaneseLineEndWrap, wpJapaneseLineHeadWrap]));
  Check(            ')))))((((()))))(((('+CRLF+'(',
    TextWordWrap(   ')))))((((()))))(((((', 19, []));
  Check(            ')))))((((()))))(((('+CRLF+'(',
    TextWordWrap(   ')))))((((()))))(((((', 19, [wpJapaneseLineHeadWrap]));
  Check(            ')))))((((()))))'+CRLF+'(((((',
    TextWordWrap(   ')))))((((()))))(((((', 19, [wpJapaneseLineEndWrap]));
  Check(            ')))))((((()))))'+CRLF+'(((((',
    TextWordWrap(   ')))))((((()))))(((((', 19, [wpJapaneseLineEndWrap, wpJapaneseLineHeadWrap]));

  {↓英単語-行末禁則}
  Check(            'ABCDE FGHI(((('+CRLF+'(',
    TextWordWrap(   'ABCDE FGHI(((((', 14, []));
  Check(            'ABCDE FGHI(((('+CRLF+'(',
    TextWordWrap(   'ABCDE FGHI(((((', 14, [wpJapaneseLineHeadWrap]));
  Check(            'ABCDE FGHI'+CRLF+'(((((',
    TextWordWrap(   'ABCDE FGHI(((((', 14, [wpJapaneseLineEndWrap]));
  Check(            'ABCDE FGHI(((('+CRLF+'(',
    TextWordWrap(   'ABCDE FGHI(((((', 14, [wpEnglishWordWrap]));
  Check(            'ABCDE FGHI'+CRLF+'(((((',
    TextWordWrap(   'ABCDE FGHI(((((', 14, [wpJapaneseLineEndWrap, wpEnglishWordWrap]));

  {↓英単語-行頭禁則}
  Check(            'ABCDE FGHI))))'+CRLF+')',
    TextWordWrap(   'ABCDE FGHI)))))', 14, []));
  Check(            'ABCDE FGHI))))'+CRLF+')',
    TextWordWrap(   'ABCDE FGHI)))))', 14, [wpJapaneseLineEndWrap]));
  Check(            'ABCDE FGH'+CRLF+'I)))))',
    TextWordWrap(   'ABCDE FGHI)))))', 14, [wpJapaneseLineHeadWrap]));
  Check(            'ABCDE FGHI))))'+CRLF+')',
    TextWordWrap(   'ABCDE FGHI)))))', 14, [wpEnglishWordWrap]));
  Check(            'ABCDE '+CRLF+'FGHI)))))',
    TextWordWrap(   'ABCDE FGHI)))))', 14, [wpJapaneseLineHeadWrap, wpEnglishWordWrap]));

  {↓行末-英単語禁則}
  Check(            'ABCDE(((((FGHI'+CRLF+'J',
    TextWordWrap(   'ABCDE(((((FGHIJ', 14, []));
  Check(            'ABCDE(((((FGHI'+CRLF+'J',
    TextWordWrap(   'ABCDE(((((FGHIJ', 14, [wpJapaneseLineHeadWrap]));
  Check(            'ABCDE(((((FGHI'+CRLF+'J',
    TextWordWrap(   'ABCDE(((((FGHIJ', 14, [wpJapaneseLineEndWrap]));
  Check(            'ABCDE((((('+CRLF+'FGHIJ',
    TextWordWrap(   'ABCDE(((((FGHIJ', 14, [wpEnglishWordWrap]));
  Check(            'ABCDE'+CRLF+'(((((FGHIJ',
    TextWordWrap(   'ABCDE(((((FGHIJ', 14, [wpJapaneseLineEndWrap, wpEnglishWordWrap]));

  {↓行頭-英単語禁則}
  Check(            'ABCDE)))))FGHI'+CRLF+'J',
    TextWordWrap(   'ABCDE)))))FGHIJ', 14, []));
  Check(            'ABCDE)))))FGHI'+CRLF+'J',
    TextWordWrap(   'ABCDE)))))FGHIJ', 14, [wpJapaneseLineEndWrap]));
  Check(            'ABCDE)))))FGHI'+CRLF+'J',
    TextWordWrap(   'ABCDE)))))FGHIJ', 14, [wpJapaneseLineHeadWrap]));
  Check(            'ABCDE)))))'+CRLF+'FGHIJ',
    TextWordWrap(   'ABCDE)))))FGHIJ', 14, [wpEnglishWordWrap]));
  Check(            'ABCDE)))))'+CRLF+'FGHIJ',
    TextWordWrap(   'ABCDE)))))FGHIJ', 14, [wpJapaneseLineHeadWrap, wpEnglishWordWrap]));
end;
//------------------------------

{-------------------------------
//  改行コードを削除する関数
//  空行はそのまま残す
備考:
履歴:   2006/04/22
          作成
//------------------------------}
function DeleteTextLineCRLF(S: WideString): String;
var
  StrRecList: TWideStringRecordList;
  i: Integer;
  LineText: WideString;
begin
  StrRecList := TWideStringRecordList.Create; try
  StrRecList.Text := S;

  for i := 0 to StrRecList.Count - 1 - 1  do
  begin
    LineText := TrimRightChar(StrRecList.Items[i], CRLF);
    if (LineText <>'') and (Trim(StrRecList.Items[i+1])<>'') then
    begin
      StrRecList.Items[i] := LineText;
    end;
  end;

  Result := StrRecList.Text;
  finally StrRecList.Free; end;
end;

function DeleteCRLF(S: WideString): String;
var
  OldPatterns, NewPatterns: TWideStringDynArray;
begin
  SetLength(OldPatterns, 2);
  SetLength(NewPatterns, 2);
  OldPatterns[0] := CR;    NewPatterns[0] := '';
  OldPatterns[1] := LF;    NewPatterns[1] := '';
  Result := WideStringsReplace(S, OldPatterns, NewPatterns);
end;
//------------------------------

const
  ItemIdWrapIndexIncrement: Integer = 1000;
  ItemIdDeleteTextCRLF: Integer     = 2001;
  ItemIdDeleteCRLF: Integer         = 2002;
  ItemIdCancel: Integer             = 2003;
  ItemIdSettingFileEdit: Integer    = 2004;

function TextWrapControl(S: WideString; WrapCtrlItemID: Integer): String;
const DefaultWrapProcess: TWrapProcesses =
        [wpEnglishWordWrap, wpEnglishDoubleByteWordWrap,
         wpJapaneseLineEndWrap, wpJapaneseLineHeadWrap];
begin
  Result := TabToSpace(S);
  if (1<=WrapCtrlItemID) and (WrapCtrlItemID<ItemIdWrapIndexIncrement) then
  begin
    Result := TextWordWrap(DeleteTextLineCRLF(Result), WrapCtrlItemID, DefaultWrapProcess);
  end else
  if (ItemIdWrapIndexIncrement+1<=WrapCtrlItemID)
    and (WrapCtrlItemID<ItemIdWrapIndexIncrement*2) then
  begin
    Result := TextWordWrap(Result, WrapCtrlItemID-ItemIdWrapIndexIncrement, DefaultWrapProcess);
  end else
  if WrapCtrlItemID = ItemIdDeleteTextCRLF then
  begin
    Result := DeleteTextLineCRLF(Result);
  end else
  if WrapCtrlItemID =ItemIdDeleteCRLF then
  begin
    Result := DeleteCRLF(Result);
  end;
end;

//(*-----------------------------------
procedure OnCommand(hwnd:HWND);stdcall;
var
  NoSelectFlag: Boolean;
  ScrollPoint: TPoint;
  SelStartPoint, SelEndPoint: TPoint;
  WideStr: WideString;
  hPopup, hSubPopup1, hSubPopup2: Integer;
  MousePoint: Windows.TPoint;
  LineStrLength: Integer;
  WrapCtrl: Integer;

  LoadSettingList: TWideStringRecordList;
  SettingFileName: String;
  WrapByteIndex: Integer;
  i: Integer;
begin
  //XPテスト
{ -----------------------------------
  testWideCharTextDrawSize;
  testTextWordWrap;
  Exit;
//----------------------------------- }
  {↓設定ファイルの処理}
  LoadSettingList := TWideStringRecordList.Create; try
  SettingFileName :=
    ExtractFilePath(ParamStr(0))+ 'PlugIns\WordWrapSetting.ini';
  if FileExists(SettingFileName) then
    LoadSettingList.Text := Trim(LoadStringFromFile(SettingFileName));
  for i := LoadSettingList.Count-1 downto 0 do
  begin
    if 1000 <= StrToIntDef(Trim(LoadSettingList.Items[i]), 1000) then
      LoadSettingList.Delete(i);
  end; {↑設定値が1000以上だったら削除}



  {↓再描画停止}
  Editor_Redraw(hwnd,FALSE); try

  {↓選択位置を保持する}
  Editor_GetSelStart( hwnd, POS_LOGICAL_W, @SelStartPoint );
  Editor_GetSelEnd( hwnd, POS_LOGICAL_W, @SelEndPoint );

  Editor_GetScrollPos(hwnd, @ScrollPoint);
  {↑スクロールバー位置をバッファ}

  {↓選択状態を保持}
  NoSelectFlag := (Editor_GetSelType(hwnd)=SEL_TYPE_NONE);
    hSubPopup1 := CreatePopupMenu;
    hSubPopup2 := CreatePopupMenu;

    hPopup := CreatePopupMenu;
    for i := 0 to LoadSettingList.Count-1 do
    begin
      WrapByteIndex := StrToInt(Trim(LoadSettingList.Items[i]));
      AppendMenu(hPopup, MF_STRING, WrapByteIndex,
                   PChar('半角'+IntToStr(WrapByteIndex)+'文字で整形'));
    end;
    
    AppendMenu(hPopup, MF_SEPARATOR, 0,    '');
    AppendMenu(hPopup, MF_POPUP, hSubPopup1, '折り返し');
    AppendMenu(hPopup, MF_POPUP, hSubPopup2, '改行削除');
    AppendMenu(hPopup, MF_SEPARATOR, 0,    '');
    AppendMenu(hPopup, MF_STRING, ItemIdSettingFileEdit, '設定');
    AppendMenu(hPopup, MF_SEPARATOR, 0,    '');
    AppendMenu(hPopup, MF_STRING, ItemIdCancel,    'キャンセル');

    for i := 0 to LoadSettingList.Count-1 do
    begin
      WrapByteIndex := StrToInt(Trim(LoadSettingList.Items[i]));
      AppendMenu(hSubPopup1, MF_STRING, WrapByteIndex+1000,
                   PChar('半角'+IntToStr(WrapByteIndex)+'文字で折り返し'));
    end;

    AppendMenu(hSubPopup2, MF_STRING, ItemIdDeleteTextCRLF, '空行を残して改行を削除');
    AppendMenu(hSubPopup2, MF_STRING, ItemIdDeleteCRLF,     '単純に改行を削除');

    Windows.GetCursorPos(MousePoint);

    WrapCtrl := Integer(TrackPopupMenu(hPopup, TPM_RETURNCMD ,
                          MousePoint.X, MousePoint.Y, 0 , hwnd , nil));

    if WrapCtrl = ItemIdCancel then
    begin
      //キャンセルなら何もしない
    end else
    if WrapCtrl = ItemIdSettingFileEdit then
    begin
      EasyCreateProcess(ParamStr(0), SettingFileName);
    end else
    begin
      {↓もし選択領域がなければ全選択する}
      if NoSelectFlag then
      begin
        Editor_ExecCommand(hwnd,EEID_EDIT_SELECT_ALL);
        {↑全選択する}
      end else
      begin
        {↓行選択状態にする}
        RowSelection(hwnd);
      end;

      {↓キャレット行の文字数を保持しておく}
      LineStrLength := Length(Editor_GetLineW_Delphi(hwnd, SelStartPoint.Y));

      WideStr := Editor_GetSelTextW_Delphi(hwnd);
      {↓文字列をセットする}
      SetSelectText(hwnd, TextWrapControl(WideStr, WrapCtrl));

      if NoSelectFlag then
      begin
        Editor_ExecCommand(hwnd, EEID_ESCAPE);
        {↑選択状態をキャンセル}

        Editor_SetCaretPos( hwnd, POS_LOGICAL_W, @SelStartPoint );
      end;

    end; //if IndentType = itCancel then

  Editor_SetScrollPos(hwnd, @ScrollPoint);
  {↑スクロールバー位置を元に戻す}
  finally Editor_Redraw(hwnd,TRUE); end;
  {↑再描画再開}

  finally LoadSettingList.Free; end;
end;
//-----------------------------------*)


{-------------------------------
//プラグインが実行可能か、またはチェックされた状態かを調べます
機能:       プラグインのEnabledを設定するイベント

            EEID_EDIT_REPLACE=指定した文字列を他の文字列で置換
            の機能が動作可能かどうかを調べると
            ファイルが書き込み可能かどうかがわかるので
            それをPluginのEnabledに反映する
履歴:       2001/02/02
--------------------------------}
function QueryStatus(hwnd:HWND; pbChecked:PBOOL ):BOOL;stdcall;
begin
  Result := Boolean(SendMessage(hwnd,EE_QUERY_STATUS,
                        EEID_EDIT_REPLACE,LPARAM(pbChecked)));
end;

////////////////////////////////////////////////////////////
{$define OnEvents}
{$include PluginBaseInclude.pas}
////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////
{$define GetID}
{$include PluginBaseInclude.pas}
////////////////////////////////////////////////////////////

//大文字小文字を間違うとエラーになるので注意
function PlugInProc(hwnd:HWND; nMsg:Integer; WPARAM:Integer; LPARAM :Integer):LRESULT; stdcall;
const
  szName : String = 'WordWrap';
  szVersion : String = 'Version 1.2';

  IDD_SPACES : Integer = 101;
////////////////////////////////////////////////////////////
{$define PluginProc_beginend}
{$include PluginBaseInclude.pas}
////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////
{$define exports}
{$include PluginBaseInclude.pas}
////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////
{$define DLLMain}
{$include PluginBaseInclude.pas}
////////////////////////////////////////////////////////////