「カッコで囲う」を編集中 (節単位)

== カッコで囲う（ポップアップメニューあり） ==
(最終更新 2020-06-23）

ポップアップメニューから任意の '''カッコ''' や '''ダッシュ''' などの種類を選択して、選択範囲をカッコやいろいろな記号、文字列で囲います。 

選択範囲がないばあい、基本的にはカーソル位置に ( ), < >, [ ], { }, 「 」, … などを挿入します。

行番号のドラッグでの複数行選択やトリプルクリックでの行選択などで末尾改行が含まれているばあい、さいごの改行を無視します。

* '''既存のポップアップメニュー項目を減らしたいばあいは'''、ソースコード内の <u>''"m.Add( … );"''</u> の行頭に '''//''' をつけてコメントアウトするとその項目をメニューから隠せます。

* '''メニュー項目を増やしたいばあいは、'''
# ソースコード冒頭の配列 pp1, pp2 の21番目～30番目に任意の <code>"記号"</code> を追加する
# 対応する番号をつけて <code>m.Add( "カッコ・記号 の名前" , XX );</code> の行を追加する
# 対応する番号をつけて <code>case XX:</code> を適当なグループに追加する

姉妹版として [[カッコをはずす|「カッコをはずす」、「カッコを削除／追加」、「カッコを追加／削除」]]マクロ、[[引用符／コメント|「引用符／コメント」]]マクロがあります。

=== メニューの項目 ===
==== 任意の文字列で囲う ====
文字入力用のダイアログで「前につける文字列」と「後ろにつける文字列」を指定します。

* '''任意の文字列１'''
:: 選択範囲全体を '''一組の''' 指定文字列で前後を囲います。
* '''任意の文字列２'''
:: 選択範囲内の '''各行ごとに''' 指定文字列で前後を囲います。ソースコード冒頭の設定項目 '''''skip''''' フラグで、複数行選択のさいに空白行をスキップするか指定してください。「wiki 文字装飾タグ」以外のカッコ／記号で '''各行ごとに囲いたい場合は、「任意の文字列２」を使用してください。'''

改行コードとタブ文字は、それぞれ「'''\\\n'''」と「'''\\\t'''」で入力されたもの (注:￥記号３つ) を改行コードとタブ文字に置換するようにしてあります。

※「\n」、「\t」と入力するとそのままの文字列「\n」、「\t」を返します。

※ 文字コードでの入力には非対応です（入力されたままの文字列を返します）。

==== カッコ／記号 で囲う ====
選択範囲全体を指定したカッコ／記号で囲います。

選択範囲なしで実行した場合は、カーソル位置にカッコ一組を挿入します。

*  (半角丸カッコ) 、 <半角山カッコ> 、 [半角角カッコ] 、 {半角波カッコ}、 （全角丸カッコ） 、 「全角かぎカッコ」 、 『二重かぎカッコ』 、 【スミ付きカッコ】
: ⇒ 選択範囲をカッコで囲います。

* ␣(半角丸カッコ)␣ 、 ␣"半角二重引用符"␣
: ⇒ 選択範囲をカッコまたは引用符で囲い、さらに半角スペースで囲います。

* ␣半角スペース␣
: ⇒ 選択範囲を半角スペースで囲います。

*  - 半角ハイフン -  、 ――ダッシュ×２―― 、 ～チルダ～
: ※ 「半角ハイフン」は、半角ハイフン=マイナス記号 <code>-</code> の '''両側''' に各１つずつ半角スペースがつきます（片側で半角３文字分）。
: ※ このグループにかぎり、選択範囲なしで実行したときは、片側分だけ　"<span style="color:#c0c0c0;">␣</span>-<span style="color:#c0c0c0;">␣</span>"　"――"　"～"　記号を挿入します。

----
●以下の '''削除系の各コマンド''' は、選択範囲がないときにはポップアップメニューに表示されません。

==== ひとつ削除 ====
* 「[[カッコをはずす]]」マクロのコードを移植しました。'''選択範囲全体の先頭/末尾''' があらかじめ用意された「対になるカッコ・記号」のペアであれば、その一組のペアを削除します。

※ ポップアップメニューの "カッコの追加用の項目" にない多種多様な記号のペアに対応します。

※「カッコをはずす」マクロの "選択範囲の外側 (前と後) にあるカッコの削除" 機能はありません。

==== 任意の 文字列／文字数 を削除 ====
「任意の文字列２」や「wiki用 マークアップ」と同様に、選択範囲内の論理行の '''各行頭と行末にたいして''' 作用します。

※ 選択範囲を "論理行単位" で拡張しないので、先頭行と末行においては行頭/行末ではなく「選択範囲の先頭/末尾」にたいして作用します。

* '''任意の文字数を削除''' ではアラビア数字（半角/全角）以外で入力された文字列をすべて無視します。例えば「'''1a２あ'''」と入力された場合は、半角数字の「'''12'''」として扱います。
* '''任意の文字列を削除''' は簡易的な処理コードなので、正規表現を使用できません。また、タブ文字の扱いは「任意の文字列２（追加）」の場合とおなじく「'''\\\t'''」で入力されたもの (注:￥記号３つ) をタブ文字（'''\t'''）として処理します。

==== 先頭／末尾の空白を削除 ====
* '''先頭／末尾から空白を削除'''
* '''先頭の空白を削除'''
* '''末尾の空白を削除'''
: ⇒ 選択範囲内の論理行の '''各行頭と行末にたいして''' 作用します。
:: 削除対象の空白文字は、「半角スペース」「全角スペース」「タブ文字」の３種です。インデント（字下げ）の解除や、行末のムダな空白文字の削除に利用できます。

※ 選択範囲を "論理行単位" で拡張しないので、先頭行と末行においては行頭/行末ではなく「選択範囲の先頭/末尾」にたいして作用します。

※ 空白を削除するだけで、「空行を削除する」ものではありません。

==== ｎ文字ずつ前後を削除 ====
* '''１文字ずつ前後を削除'''
* '''２文字ずつ前後を削除'''
* '''３文字ずつ前後を削除'''
: ⇒ '''選択範囲全体の先頭/末尾から''' 指定の文字数ずつ削除します。

* '''１文字ずつ前後を削除（外側）'''
: ⇒ '''選択範囲全体の前と後ろの''' 各１文字を削除します。
※ 選択範囲が先頭行の行頭から始まっている場合や、最終行の行末で終わっている場合は、選択範囲内の先頭または末尾の１文字が削除されます。

----

==== JS / XML コメントアウト ====
３種類の '''挿入型コメントアウト''' のメタ記号で選択範囲の文字列をコメントアウトできます。また、アンコメント用のコマンドでコメントアウト状態を解除できます。
* '''/* JavaScript 挿入型コメントアウト１ */'''
: ⇒ 選択範囲全体を '''<code>/* </code>''' と ''<code>' */</code>''' で囲います。

* '''/* *JavaScript コメントアウト２（ブロックコメント） */'''
:: /* <br>  * （複数行の）選択範囲全体を　"'''<code>/* \n</code>'''"　と　"'''<code>\n */</code>'''"　で囲い、<br>  * 範囲内の各行の行頭に　"'''<code> * </code>'''"　を付けます。<br>  */

* '''<nowiki><!-- XML 挿入型コメントアウト --></nowiki>'''
: ⇒ 選択範囲全体を　'''<syntaxhighlight lang="javascript" inline><!-- </syntaxhighlight>'''　と　'''<syntaxhighlight lang="javascript" inline> --></syntaxhighlight>'''　で囲います。

* '''JS アンコメント'''
* '''XML アンコメント'''
: ⇒ 上の３種のコメントアウトのメタ記号を削除してアンコメントします。

※ <u>先頭と末尾のコメントマークは選択範囲の両端でなければ削除されません</u>（選択範囲の先頭/末尾に半角スペース×１が付いていても、コメントマークといっしょに削除できます）。また、選択範囲内に２組以上のコメントがあると、正常にアンコメントできません。

※ "JS アンコメント" は中間行の行頭記号（アスタリスクと全角/半角中黒）とその前後の半角スペースを削除します。これらの行頭記号を使用した'''箇条書き'''を範囲選択して実行すると、同様に行頭記号を削除します。

※ プログラミングをしない人には使いみちがないとおもいますので、ZIP のソースでは初期状態でコメントアウトしてあります。

==== Wiki用 マークアップ ====
５種類の wiki用 文字列装飾タグ（[https://www.mediawiki.org/wiki/Help:Formatting/ja テキスト整形マークアップ]）を挿入できます。

選択範囲内の '''各行ごとに''' 指定のタグで前後を囲います。ソースコード冒頭の設定項目 '''''skip''''' フラグで、複数行選択のさいに空白行をスキップするか指定してください。

* '''太字'''
: ⇒ 選択範囲全体を '''<syntaxhighlight lang="javascript" inline>'''</syntaxhighlight>'''（シングルクオート×３） で囲います。

* ''斜体（Italic）''
: ⇒ 選択範囲全体を '''<syntaxhighlight lang="javascript" inline>''</syntaxhighlight>'''（シングルクオート×２） で囲います。

* <u>下線</u>
: ⇒ 選択範囲全体を　'''<syntaxhighlight lang="javascript" inline><u></syntaxhighlight>'''　と　'''<syntaxhighlight lang="javascript" inline></u></syntaxhighlight>'''　で囲います。

* <nowiki>[[内部リンク]]</nowiki>
: ⇒ 選択範囲全体を　'''<code>[[</code>'''　と　'''<code>]]</code>'''　で囲い、<nowiki>[[リンク|ラベル]]</nowiki> 型の [https://www.mediawiki.org/wiki/Help:Links/ja#Internal_links 内部リンク] にします。

* <nowiki>マークアップ回避</nowiki>
: ⇒ 選択範囲全体を　'''<code><nowiki></code>'''　と　'''<code></nowiki></code>'''　で囲います。

※ wiki用 文字列装飾タグのままでは使いみちがないとおもいますので、HTML タグ <nowiki><a> </a></nowiki> などに書き換えてしまうか、ポップアップメニュー項目をコメントアウトしてしまうとよいでしょう（ZIP のソースでは初期状態でコメントアウトしてあります）。

==== Mery マクロ用 ====
選択範囲の文字列をコピーし、"二重引用符" つきにして、以下の各種の構文で囲います。

※選択文字列のある行の '''ひとつしたの行''' に各構文を挿入します。

※選択範囲が複数行の場合は　'''+ "\n" +'''　でつなぎ合わせます。

* '''アウトプット'''
: ⇒ <code>Outputbar.Writeln( "..." );</code>　の構文にしてアウトプットバーを表示状態にします。
* '''アラート'''
: ⇒ <code>Alert( "..." );</code>　の構文にします。
* '''コンファーム'''
: ⇒ <code>Confirm( "..." );</code>　の構文にします。
* '''ステータス'''
: ⇒ <code>Status = "...";</code>　の構文にします。

※ マクロのプログラミングをしない人には使いみちがないとおもいますので、ZIP のソースでは初期状態でコメントアウトしてあります。

=== ソースコード ===
<syntaxhighlight lang="javascript" style="height:80em; overflow:auto;">
#title = "カッコ ..."
#tooltip = "カッコで囲う (ポップアップメニュー）"
#icon = "brackets(parenthesis)[2].ico"
// #icon = "Mery用 マテリアルデザインっぽいアイコン.icl",255

/**
 * -----------------------------------------------------------------------------
 * カッコで囲う(ポップアップメニュー）
 * sukemaru, 2018-08-24 - 2020-06-23
 * -----------------------------------------------------------------------------
 * (Last modified: 2020-06-23)
 * 	マルチカーソル／複数選択範囲に対応
 * 	入力ダイアログを使用する処理を関数化
 * 	カッコの定義配列の変数名を変更（p1 ⇒ pp1, p1 ⇒ pp1）
 * (2020-06-03)
 * 	カッコで囲まれた文字列が2つできてしまう不具合を修正
 * 	処理コード内の一部の変数名を変更
 * -----------------------------------------------------------------------------
 */

// ---------- ▼ 設定項目 ▼ ---------- //

// ■「任意の文字列２」と、wiki 文字装飾タグで、複数行の選択範囲内の空白行をスキップするか？
var skip = true;	// （true; スキップする ／ false; スキップしない）

// 「任意の文字列」で入力した文字列の一時記憶方法
var tagType = 2;
  // 0 ： 一時記憶なし
  // 1 ： タブ（文書）ごとに一時記憶する（Document.Tag）
  // 2 ： ウインドウごとに一時記憶する（Editor.Tag）
  // 3 ： すべてのタブとウインドウ共通で一時記憶する（window.Tag）


// ■開きカッコを配列で定義する
var pp1 = [ "" ,		// 以下 r = 1～10、11～20、21～ の ID 順
  "(" ,  "<" ,  "[" ,  "{" ,  "（" ,  "「" ,  "『" ,  "【" ,  " （" ,  " (" ,
  " \"" ,  " " ,  " - " ,  "――" ,  "～" ,  "'''" ,  "''" ,  "<u>" ,  "[[" , "<nowiki>" ,
  "" , "" , "" , "" , ""
];

// ■閉じカッコを配列で定義する
var pp2 = [ "" ,		// 以下 1～10、11～20、21～ の ID 順
  ")" ,  ">" ,  "]" ,  "}" ,  "）" ,  "」" ,  "』" ,  "】" ,  "） " ,  ") " ,
  "\" " ,  " " ,  " - " ,  "――" ,  "～" ,  "'''" ,  "''" ,  "</u>" ,  "]]" , "</nowiki>" ,
  "" , "" , "" , "" , ""
];

// ---------- ▲ 設定項目 ▲ ---------- //


var m = CreatePopupMenu();
var d = editor.ActiveDocument;
if ( d.ReadOnly ) {
  m.Add( "　ドキュメントは 書き換え禁止 です & ", 0 );
}

else {
  var s = editor.ActiveDocument.selection;
  var grayFlag = s.Text ? 0 : meMenuGrayed;

  // m.Add( "ラベル", r ); の各行は、任意に上下移動（並べ替え）してよいが、
  // r の数値は上の配列の並び順やテキスト変換処理の case r: に対応しているので変更しないこと！

  /* 入力 ダイアログ */
  m.Add( "任意の文字列 で前後を囲う (&E) ...", 1050 );	// Enter the custom string(s)
  m.Add( "任意の文字列 ２ （各行） (&F) ...", 1051 );	// 各行ごとに指定文字列で囲う（skip フラグを指定すること）

  /* 削除系コマンド */
  if ( s.Text ) {	// 選択範囲がないときは表示しない
    m.Add( "", 0, meMenuSeparator );
    m.Add( "▲ ひとつ削除 (&1)", 1038 );
    m.AddPopup( "● 削除 (&T)", sm1 = CreatePopupMenu() );
      sm1.Add( "　　先頭／末尾から任意の 文字列 を削除 （各行） (&Z) ...", 1052 );
      sm1.Add( "　　先頭／末尾から任意の 文字数 を削除 （各行） (&X) ...", 1053 );
      sm1.Add( "", 0, meMenuSeparator );
      sm1.Add( "≫ 先頭／末尾から 空白 を削除 ≪ （各行） (&W)", 1037 );
      sm1.Add( "≫ 先頭の 空白 を削除　　 （各行） (&T)", 1035 );
      sm1.Add( "　　末尾の 空白 を削除 ≪ （各行） (&B)", 1036 );
      sm1.Add( "", 0, meMenuSeparator );
      sm1.Add( "◀  1文字ずつ 前後を削除  ▶ （外側） (&0)", 1034 );
      sm1.Add( " ▶ &1文字ずつ前後を削除 ◀  (１)", 1031 );
      sm1.Add( " ▶ &2文字ずつ前後を削除 ◀  (２)", 1032 );
      sm1.Add( " ▶ &3文字ずつ前後を削除 ◀  (３)", 1033 );
  }

  /* カッコ */
  m.Add( "", 0, meMenuSeparator );
  m.Add( " ( 半角 小カッコ )  (&P)", 1 );       // Parenthesis
  m.Add( "", 0, meMenuSeparator );
  m.Add( "< 半角 山カッコ > (&A)", 2 );         // Angle brackets
  m.Add( " [ 半角 大カッコ ]  (&B)", 3 );       // square Brackets
  m.Add( " { 半角 中カッコ }  (&C)", 4 );       // Curly brackets

  m.Add( "", 0, meMenuSeparator );
  m.Add( "（ 全角 小カッコ ） (&R)", 5 );       // Round brackets
  m.Add( "", 0, meMenuSeparator );
  m.Add( "「 全角 かぎカッコ 」 (&K)", 6 );     // Kakko
  m.Add( "『 全角 二重かぎカッコ 』 (&W)", 7 ); // White corner brackets
  m.Add( "【 全角 スミ付きカッコ 】 (&L)", 8 ); // Lenticular brackets

  m.Add( "", 0, meMenuSeparator );
  m.Add( "␣（ 全角 小カッコ ）␣ (&F)", 9 );     // Full width parenthesis (w/ space)
  m.Add( "␣ ( 半角 小カッコ ) ␣ (&H)", 10 );    // Half-width parenthesis (w/ space)
  m.Add( '␣ "  半角 引用符  " ␣ (&Q)', 11 );    // double-Quotation mark (w/ space)
  m.Add( "␣  半角 スペース  ␣ (&S)", 12 );      // Space

  m.Add( "", 0, meMenuSeparator );
  m.Add( "  -   半角 ハイフン   -   (&-)", 13 );    // hyphen-minus  (w/ spaces)
  m.Add( "―― 全角 ダッシュ ―― (&D)", 14 );      // Dash
  m.Add( "～ 全角 チルダ ～ (&T)", 15 );            // Tilde

  /* JS コメントアウト ／ XML コメントアウト */
//   m.Add( "", 0, meMenuSeparator );
//   m.Add( "/* *  JS コメントアウト ２  */ (&J)", 1041 );  // JavaScript comment out (block comment)
//   m.Add( "/*  JS コメントアウト １  */ (&V)", 1042 );    // jaVascript comment out
//   m.Add( "▲  JS  アンコメント (&U)", 1043, grayFlag );  // Uncomment
//   m.Add( "", 0, meMenuSeparator );
//   m.Add( "<!--  XML コメントアウト  --> (&X)", 1044 );   // Xml comment out
//   m.Add( "▲  XML アンコメント (&M)", 1045, grayFlag );  // xMl uncomment

  /* wiki マークアップ
     このブロックの項目は、複数行を選択しているとき「選択範囲の各行ごとに囲う」処理をおこなう
    ※ skip フラグを指定すること */
//   m.Add( "", 0, meMenuSeparator );
//   m.AddPopup( "wiki 文字修飾 （各行） (&W)", sm2 = CreatePopupMenu() );
//     sm2.Add( "'''  wiki 太字  '''  (&B)", 16 );      // Bold
//     sm2.Add( "''   wiki 斜体   ''  ( &I )", 17 );    // Italic
//     sm2.Add( "<u> wiki 下線 </u>  (&U)", 18 );       // Under line
//     sm2.Add( "[[   wiki リンク   ]]  (&L)", 19 );    // Link
//     sm2.Add( "<nowiki>  </nowiki>  (&N)", 20 );      // Nowiki

  /* Mery マクロ用
     以下の項目は、選択範囲の文字列をコピーして、一行下でそれぞれの構文で囲う */
//   m.Add( "", 0, meMenuSeparator );
//   m.AddPopup( "Mery マクロ (&Y)", sm3 = CreatePopupMenu() );
//     sm3.Add( "アウトプット (&O)", 1060 );        // OutputBar.Writeln( ... )
//     sm3.Add( "アラート (&A)", 1061 );            // Alert( ... )
//     sm3.Add( "コンファーム (&C)", 1062 );        // Confirm( ... )
//     sm3.Add( "ステータス (&S)", 1063 );          // Status = ...

  m.Add( "", 0, meMenuSeparator );
  m.Add( "キャンセル\t& ", 0 );
}

// ポップアップメニューを表示
// m.Track(0); ならキャレット位置、m.Track(1); ならカーソル位置にポップアップ
var r = m.Track( mePosMouse = 1 );	// 選択されたメニュー項目のIDを r に格納する


if ( r > 0 ) {
  Redraw = false;

// ---------- ▼ マルチカーソル／複数選択範囲対応 ▼ ---------- //

  var tagKey = "AddBrackets2";
  var p, p1, p2;
  if ( r === 1050 || r === 1051 ) {	// 「任意の文字列を追加」
    p = Brackets2Prompt( tagType, tagKey );
    p1 = p.p1;  p2 = p.p2;
  }
  else if ( r === 1052 ) {			// 「任意の文字列を削除」
    p = DelStrPrompt( tagType, tagKey );
    p1 = p.p1;  p2 = p.p2;
  }
  else if ( r === 1053 ) {			// 「任意の文字数を削除」
    p = DelByNumPrompt();
    p1 = p.p1;  p2 = p.p2;
  }
  else {
    p1 = pp1[r];  p2 = pp2[r];
  }

  if ( p1 || p2 || r > 1000 ) {
    // マルチカーソル／複数選択に対応
    var arg = [ r, p1, p2, skip ];
    // 選択範囲が１つで矩形選択ではないとき
    if ( ! s.Mode || s.Mode === meModeStream ) {
      AddBrackets_Main( arg );
    }
    // 矩形選択または複数選択のとき
    else {
      var sx = ScrollX,  sy = ScrollY;
      BeginUndoGroup();
      AddUndo();
      MultiFunction( AddBrackets_Main, arg );
      EndUndoGroup();
      ScrollX = sx;  ScrollY = sy;
    }
  }

  Redraw = true;
}

/**
 * 関数 function AddBrackets_Main( [ r, p1, p2, skip ] )
 * カッコで囲う(ポップアップメニュー）のメイン処理
 */
function AddBrackets_Main( arg ) {
  var r    = arg[0];
  var p1   = arg[1];
  var p2   = arg[2];
  var skip = arg[3];

  // マクロ実行前の選択範囲の各座標を取得
  var d = editor.ActiveDocument,  s = d.selection;
  var anc = s.GetAnchorPos(),  act = s.GetActivePos();
  var tp = ( anc < act ) ? anc : act;
  var bp = ( anc < act ) ? act : anc;
  // 選択範囲がなければカーソル位置を取得
  if ( s.IsEmpty ) {
    var pos = s.GetActivePos();
  }
  var tx = s.GetTopPointX( mePosLogical );
  var ty = s.GetTopPointY( mePosLogical );
  var bx = s.GetBottomPointX( mePosLogical );
  var by = s.GetBottomPointY( mePosLogical );
  // 選択範囲の末尾位置を調整（最後の \n を含めない）
  // ※ { 中カッコ } のばあいは末尾の調整をしない
  if ( ! s.IsEmpty && bx == 1 && r != 4 ) {
    s.SetActivePos( bp - 1 );
    s.SetAnchorPos( tp );
  }

  // 選択範囲の文字列を取得
  var st = tmp = s.Text;

  // IDごとのテキスト変換処理
  switch ( r ) {

  // カッコ
  case 1:  case 2:  case 3:  case 4:  case 5:  case 6:
  case 7:  case 8:  case 9:  case 10:  case 11:  case 12:
  case 21:  case 22:  case 23:  case 24:  case 25:
    // カッコ p1 ＆ p2 で囲う
    s.Text = p1 + st + p2;
    // 選択範囲があれば選択範囲を復元
    if ( st ) { s.SetAnchorPos( tp ); }
    // 選択範囲がなければカーソルをカッコのなかに移動
    else { s.SetActivePos( pos + p1.length ); }
    break;

  // ハイフン、ダッシュ、チルダ
  case 13:  case 14:  case 15:
    // 選択範囲があればダーシ p1 ＆ p2 で囲う
    if ( st ) {
      s.Text = p1 + st + p2;
      s.SetAnchorPos( tp );	// 選択範囲を復元
    }
    // 選択範囲がなければ片側分 p1 だけ挿入
    else { s.Text =  p1; }
    break;

  // wiki 文字装飾タグ	※ 太字／斜体／下線／<nowiki>
  // 選択範囲内の「各行を囲う」処理をおこなう。
  // 複数行選択で空白行をスキップするかは冒頭の skip フラグで決定する。
  // 選択範囲なしで実行するとタグの間がわかりづらくなるので全角スペースを挿入する。
  case 16:  case 17:  case 18:  case 20:
    // 選択範囲があれば各行を p1 ＆ p2 で囲う
    if ( st ) {
      tmp = AddBrackets( st, p1, p2, skip );
      if ( tmp != st ) {
        s.Text = tmp;
        s.SetAnchorPos( tp );	// 選択範囲を復元
      }
      else {	// テキストに変更なしなら選択範囲の復元だけ
        s.SetActivePos( act );  s.SetAnchorPos( anc );
      }
    }
    // 選択範囲がなければ p1 ＆ p2 と全角スペースを挿入
    else {
      s.Text = p1 + "　" + p2;
      s.SetAnchorPos( pos + p1.length );			// カーソルをタグのなかに移動
      s.SetActivePos( s.GetAnchorPos() + 1, true );	// 全角スペースを範囲選択
    }
    break;

  // wiki 文字装飾		※ 内部リンク用タグ	[[リンク|ラベル]]
  // 選択範囲内の「各行を囲う」処理をおこなう。
  // 複数行選択で空白行をスキップするかは冒頭の skip フラグで決定する。
  case 19:
    // 選択範囲があれば各行を [[str|str]] に変換
    if ( st ) {
      var tmp = AddWikiLink( st, p1, p2, skip );
      if ( tmp != st ) {
        s.Text = tmp;
        s.SetActivePos( tp + p1.length );	// p1 の後ろにカーソルを移動
      }
      else {	// テキストに変更なしなら選択範囲の復元だけ
        s.SetActivePos( act );  s.SetAnchorPos( anc );
      }
    }
    // 選択範囲がなければ p1 ＆ p2 と " | " を挿入
    else {
      s.Text = p1 + "　|　" + p2;
      s.SetActivePos( pos + p1.length );			// カーソルをカッコの中に移動
      s.SetAnchorPos( s.GetActivePos() + "　|　".length );	// カッコの中を範囲選択
    }
    break;

  // n文字ずつ前後を削除（内）
  case 1031:  case 1032:  case 1033:
    if ( st ) {
      // 選択範囲の両端から n 文字ずつ消す
      var n = ( r - 1030 );
      s.Text = st.slice( n, st.length - n );
      s.SetAnchorPos( tp );	// 選択範囲を復元
    }
    break;

  // １文字ずつ前後を削除（外）
  case 1034:
    s.SetAnchorPos( tp - 1 );			// 選択範囲の先頭側を１文字拡張
    s.SetActivePos( bp + 1, true );		// 選択範囲の末尾側を１文字拡張
    s.Text = s.Text.slice( 1, - 1 );	// 先頭/末尾を１文字ずつ削除
    s.SetAnchorPos( tp - 1 );			// 選択範囲を復帰する
    break;

  // 行頭／行末の空白を削除	※選択範囲を論理行単位に拡張はしない
  case 1035:  case 1036:  case 1037:
    if ( st ) {
      tmp = ( r == 1037 ) ? st.replace( /^[\t 　]*|[\t 　]*$/gm , "" ) :	// 行頭／行末
            ( r == 1035 ) ? st.replace( /^[\t 　]*/gm , "" ) :	// 行頭
           /* r == 1036 */  st.replace( /[\t 　]*$/gm , "" ) ;	// 行末

      // 選択範囲に指定文字列がなかった場合 undo 履歴を残さない
      if ( tmp != st ) {
        s.Text = tmp;			// 削除完了
        s.SetAnchorPos( tp );	// 選択範囲を復元
      }
    }
    break;

  // ひとつ削除 （※「カッコをはずす」マクロのコードを流用）
  case 1038:
    // 「ひとつ削除」用のカッコの定義
    var brackets = "  ()｢｣<>[]{}\"\"''"
    + "（）「」『』＜＞［］｛｝【】〖〗⦅⦆｟｠〚〛〔〕〘〙〈〉《》"
    + "””’’〝〞〝〟‘’“”――～～〜〜"
    + "++--**\/\/##==%%::：：@@＠＠※※††｜｜……␣␣＿＿"
    + "○○●●□□■■◇◇◆◆▽▽▼▼△△▲▲☆☆★★"
    + "←→→←↑↓↓↑←←→→↑↑↓↓"
    + "¿?¡!‚‘‚’„“„”“„‘‚‹››‹«»»«——‐‐－－"
    + "﹁﹂﹃﹄︵︶︿﹀︽︾︹︺︷︸︻︼︗︘";
    var brackets2 = [
      "<b>", "</b>" , "<i>", "</i>" , "<u>", "</u>" , "<s>", "</s>" ,
      "</", ">" , "<", "/>" , "<!-- ", " -->" , "<!--", "-->" , 
      "/** \n", "\n */" , "/** \n", "\n*/" , "/**\n", "\n */" , "/**\n", "\n*/" , 
      "/* \n", "\n */" , "/* \n", "\n*/" , "/*\n", "\n */" , "/*\n", "\n*/" , 
      "/** ", " */" , "/**", " */" , "/* ", " */" , "/*", " */" , 
      "'''''", "'''''" , "'''", "'''" , "''", "''" , "[[", "]]" ,  
      "<nowiki>", "</nowiki>" , "<span>", "</span>" , "<div>", "</div>" , 
      "<pre>", "</pre>" , "<source lang=\"javascript\">", "</source>" 
    ];
    brackets = brackets2.concat( brackets.split( "" ) );

    tmp = DeleteBrackets( st, brackets );
    if ( st != tmp ) {
      s.Text = tmp;
      s.SetAnchorPos( tp );	// 選択範囲を復帰する
    }
    else {	// テキストに変更なしなら選択範囲の復元だけ
      s.SetActivePos( act );  s.SetAnchorPos( anc );
    }
    break;

  // /* * JavaScriptコメントアウト ２ */
  case 1041:
/*
 *   基本的に１行めが行の先頭から始まることしか想定していないので、
 *   あらかじめコメントアウトする文字列は、行単位でまとまったブロックにしておくとよい。
 *   選択範囲の先頭／末尾が行の途中にある状態でコメントアウトする場合は、改行を追加する。
 */

    p1 = ( tx > 1 ) ? "\n/\*\n" : "/\*\n";
    p2 = ( document.Text.charAt( bp ) != "\n" ) ? "\n */\n" : "\n */";
    var ast = " * ";
    // 選択範囲の先頭座標が x = 1 でなければ改行させるので選択範囲の復元用座標を調整
    if ( tx > 1 ) { tp ++; }

    // コメントアウト
//    s.Text = CommentOutJS( st, p1, p2, ast );	// コメントアウト（関数バージョン）
    /*  ※ JS コメントアウト の正規表現置換バージョンの検証は不十分 ※ */ 
    s.Text = p1 + st.replace( /^(.*)$/gm, ast + "$1" ) + p2;

    // 選択範囲があれば選択範囲を復元
    if ( st ) { s.SetAnchorPos( tp ); }
    // 選択範囲がなければカーソルをコメント枠のなかに移動
    else { s.SetActivePos( s.GetActivePos() - p2.length ); }
    break;

  /* JavaScript コメントアウト １ */
  // <!-- XML コメントアウト --> 
  case 1042:  case 1044:
    /* JavaScript コメントアウト １ */
    if ( r == 1042 ) { p1 = " /\* ";  p2 = " */ "; }
    // <!-- XML コメントアウト --> 
    else { p1 = " <!-- ";  p2 = " --> "; }
    s.Text = p1 + st + p2;
    // 選択範囲があれば選択範囲を復元
    if ( st ) { s.SetAnchorPos( tp ); }
    // 選択範囲がなければカーソルをコメント枠のなかに移動
    else { s.SetActivePos( pos + p1.length ); }
    break;

  // JS アンコメント:
  // case 1041 と case 1042: の /* JavaScriptコメント */ をアンコメントする。
  // 選択範囲内の各行頭のコメントマーク "/* "  と " * " と " */" のみマッチ。
  // 「カッコで囲う」では行の先頭部分のコメントマークだけにしかマッチしないので、
  // コメント部分がインデントされている場合は「引用符／コメント」マクロのJSアンコメントを使うこと。
/* 
 * ・選択範囲に複数のコメントブロックがある場合を想定していない。
 * ・中間行の行頭記号はアスタリスク「 * 」、全角中黒「・」、半角中黒「･」を削除対象とする。
 *   （行頭記号と前後の半角スペース各１を削除する）
 * ・JSコメントでない箇条書き文で実行した場合も行頭のビュレット「* ・ ･」を削除する。
 */
/* このタイプのコメントにたいしてもアンコメント処理する。 */

  // XML アンコメント:
  // case 1044 の <!-- XMLコメント --> をアンコメントする。
  // 選択範囲の先頭の " <!-- " と 末尾の " --> " のみマッチ。
  // 選択範囲に複数のコメントがあると正常にアンコメントしない。

  case 1043:  case 1045:
    // 選択範囲の先頭と末尾のコメントマークを削除
//    if ( r == 1043 ) {
//      // JS アンコメント（関数バージョン）
//      tmp = UnCommentJS( st );
//    }
    /*  ※ JS アンコメントの正規表現置換バージョンの検証は不十分 ※ */ 
    // JS アンコメント（正規表現バージョン）
    if ( r == 1043 ) {
      tmp = st.replace( /^ ?\/\*+ ?\n?|\n? ?\*+\/ ?$/gm, "" )
              .replace( /^ ?(?:\*+|[・･]) ?/gm, "" );
    }
    // XML アンコメント
    else {	// ( r == 1045 )
      tmp = st.replace( /^ ?<!-+ ?| ?-+ *>\ ?$/g, "" );
    }
    // 選択範囲にコメントマークがなかった場合 undo 履歴を残さない
    if ( tmp == st ) {		// テキストに変更なしなら選択範囲の復元だけ
      s.SetActivePos( act );  s.SetAnchorPos( anc );
    }
    else {
      s.Text = tmp;			// アンコメント完了
      s.SetAnchorPos( tp );	// 選択範囲を復元
    }
    break;

  // 任意の文字列を追加	※テキストボックス
  case 1050:  case 1051:
    if ( p1 || p2 ) {
      if ( st ) {
        // 「任意の文字列１」	選択範囲全体を p1 ＆ p2 で囲う
        if ( r == 1050 ) {
          s.Text = p1 + st + p2;
        }
        // 「任意の文字列２」	選択範囲の各行を p1 ＆ p2 で囲う
        else {
          tmp = AddBrackets( st, p1, p2, skip );
          if ( tmp != st ) { s.Text = tmp; }
          else { s.SetActivePos( bp ); }
        }
        s.SetAnchorPos( tp );	// 選択範囲を復元
      }
      // 選択範囲がなければ p1 ＆ p2 を挿入し、カーソルをカッコのなかに移動
      else {
        s.Text = p1 + p2;
        s.SetActivePos( pos + p1.length );
      }
    }
    break;

  // 各行の前後から任意の文字数／文字列を削除	※テキストボックス
  case 1052:  case 1053:
    if ( st ) {
      // 「任意の文字数を削除」	各行の先頭/末尾から指定文字数を削除
      if ( r == 1053 ) {
        tmp = DeleteCharByNum( st, p1, p2 );
      }
      // 「任意の文字列を削除」	各行の先頭/末尾の指定文字列を削除
      else {	// ( r == 1052 )
        var reg = new RegExp(
          "^" + p1.replace( /[.*+?^=!:${}()|[\]\/\\]/g, "\\$&" )
        + "|" + p2.replace( /[.*+?^=!:${}()|[\]\/\\]/g, "\\$&" ) + "$"
        , "gm" );
        tmp = st.replace( reg , "" );
      }
      // 選択範囲に指定文字列がなかった場合 undo 履歴を残さない
      if ( tmp != st ) {
        s.Text = tmp;			// 削除完了
        s.SetAnchorPos( tp );	// 選択範囲を復元
      }
    }
    break;

  // アウトプット ／ アラート ／ コンファーム ／ ステータス
  /**
   * 選択範囲の文字列 st をコピーして、１行下に
   * OutputBar.Writeln( "st" );
   * Alert( "st" );
   * Confirm( "st" );
   * Status = "st";
   * の行を追加する
   * → 追加した行の移動は「行を上/下に移動」マクロで
   * → 引用符がジャマなら「引用符で囲う」マクロで除去を…
   */
  case 1060:  case 1061:  case 1062:  case 1063:
    s.SetActivePoint( mePosLogical, 1, by + 1 );
    // 選択範囲が複数行なら +"\n"+ でつなぐ
    tmp = '"' + st.replace( /\n/g, '" + "\\n" + "' ) + '"';
    var sur = ( ( r == 1063 ) ? ";" : " );" ) + "\n";
    s.Text  = ( ( r == 1060 ) ? "OutputBar.Writeln( " :
                ( r == 1061 ) ? "Alert( " :
                ( r == 1062 ) ? "Confirm( " :
               /* r == 1063 */  "Status = "
              ) + tmp + sur;
    // カッコの中の文字列を範囲選択する
    s.SetActivePos( s.GetActivePos() - sur.length );
    s.SetAnchorPos( s.GetActivePos() - tmp.length );
    // アウトプットの場合は、アウトプットバーを表示
    if ( r == 1060 ) {
      ScrollY = s.GetActivePointY( mePosView );
      OutputBar.Visible = true;
    }
    break;

  default:
    break;
  }
}


/* 関数 AddBrackets( str, p1, p2, skip ) */
function AddBrackets( str, p1, p2, skip ) {
  var a = str.split( "\n" );	// 選択範囲 st を "\n" で区切って配列 a に
  for ( var i = 0, len = a.length; i < len; i ++ ) {
    // skip = true のときは、空白行をスキップ
    if ( str && skip && /^\s*$/.test( a[i] ) ) { continue; }
    // 空行にカッコを挿入する場合は全角スペースをはさむ
    var space = ( ( p1.length && p2.length ) && ( ! str || ! a[i].length ) )
              ? "　" : "" ;
    a[i] = p1 + space + a[i] + p2;	// 各行をカッコ p1 ＆ p2 で囲う
  }
  return a.join( "\n" );
}


/* 関数 AddWikiLink( str, p1, p2 skip ) */
function AddWikiLink( str, p1, p2, skip ) {
  var a = str.split( "\n" );		// 選択範囲 st を "\n" で区切って配列 a に
  for ( var i = 0, len = a.length; i < len; i ++ ) {
    // skip = true のときは、空白行をスキップ
    if ( str && skip && /^\s*$/.test( a[i] ) ) { continue; }
    // 空行には全角スペースつきではさむ
    var bar = ( ! str || ! a[i].length ) ? "　|　" : "|" ;
    a[i] =  p1 + a[i] + bar + a[i] + p2;	// 各行を [[str|str]] に置換
  }
  return a.join( "\n" );
}


/* 関数 DeleteCharByNum( st, p1, p2 ) */
function DeleteCharByNum( str, p1, p2 ) {
  var a = str.split( "\n" );
  for ( var i = 0, len = a.length; i < len; i ++ ) {
    // 各行の先頭/末尾からの指定文字数を削除
    a[i] = a[i].slice( p1, a[i].length - p2 );
  }
  return a.join( "\n" );
}


/* 関数 DeleteBrackets( str, brackets ) */
// 選択範囲の先頭と末尾から１組のカッコを削除する
function DeleteBrackets( str, brackets ) {
  // ループ処理で「対になるカッコ」と一致するかチェック
  for ( var i = 0, len = brackets.length; i < len; i ++ ) {
    if ( i % 2 == 1 || ! brackets[i].length ) { continue; }
    var o = brackets[ i ];		// 開きカッコ
    var c = brackets[ i + 1 ];	// 閉じカッコ

    // 選択範囲内の先頭と末尾が「対になるカッコ」のとき
    if ( str.length >= o.length + c.length
    && str.slice( 0, o.length ) == o
    && str.slice( - c.length ) == c ) {
      str = str.slice( o.length, - c.length );	// 先頭/末尾のカッコを削除
      break;
    }
  }
  return str;
}


/**
 * 関数 ToHalfWidth( strVal )
 * 全角英数記号を半角変換して返す
 */
function ToHalfWidth( strVal ){
  // 半角変換（文字コードをシフト）
  return strVal.replace( /[！-～]/g, function( tmpStr ) {
    return String.fromCharCode( tmpStr.charCodeAt(0) - 0xFEE0 );
  } );
}


/**
 * 関数 GetTag( tagType, tagKey, property )
 * 指定された Tag の値を返す
 */
function GetTag( tagType, tagKey, property ) {
  try {
    var obj = ( typeof tagType === "object" ) ? tagType
            : ( tagType === 1 ) ? editor.ActiveDocument
            : ( tagType === 2 ) ? editor
            : ( tagType === 3 ) ? window
            : window;
    return ( obj.Tag.Exists( tagKey )
    && ( property ? property in obj.Tag( tagKey ) : true ) )
    ? property
      ? obj.Tag( tagKey )[ property ]
      : obj.Tag( tagKey )
    : null;
  } catch( e ) { Status = e;  return null; }
}


/**
 * 関数 SetTag( value, tagType, tagKey, property )
 * 指定された値を Tag に書き込む
 */
function SetTag( value, tagType, tagKey, property ) {
  try {
    var obj = ( typeof tagType === "object" ) ? tagType
            : ( tagType === 1 ) ? editor.ActiveDocument
            : ( tagType === 2 ) ? editor
            : ( tagType === 3 ) ? window
            : window;
    if ( property ) {
      if ( obj.Tag.Exists( tagKey ) ) {
        obj.Tag( tagKey )[ property ] = value;
      }
      else { obj.Tag( tagKey ) = { property: value }; }
    }
    else { obj.Tag( tagKey ) = value; }
  }
  catch( e ) { Status = e; }
  finally { return; }
}


/**
 * 関数 Brackets2Prompt( tagType, tagKey )
 * 「任意の文字列」コマンド
 * 開きカッコと閉じカッコ
 * 入力ダイアログで指定された文字列を返す
 */
function Brackets2Prompt( tagType, tagKey ) {
  // 前回使用した文字列があればダイアログの初期値に再利用
  var str1 = str2 = "";
  if ( tagType && ( t = GetTag( tagType, tagKey, "addStr" ) ) ) {
    str1 = t.str1;  str2 = t.str2;
  }
  // 入力ダイアログ
  var msg = "につける文字列:\t"
          + "改行 = \\\\\\ｎ ; タブ = \\\\\\ｔ  (注:￥記号３つ)";
  p1 = Prompt( "前" + msg, str1 ).replace( /\\\\\\t/g, "\t" )
                                 .replace( /\\\\\\n/g, "\n" );
  p2 = Prompt( "後ろ" + msg, str2 ).replace( /\\\\\\t/g, "\t" )
                                   .replace( /\\\\\\n/g, "\n" );
  if ( ! p1 && ! p2 ) { return { p1: "",  p2: "" }; }
  if ( tagType ) {
    var value = {
      str1: p1.replace( /\t/g, "\\\\\\t" ).replace( /\n/g, "\\\\\\n" ),
      str2: p2.replace( /\t/g, "\\\\\\t" ).replace( /\n/g, "\\\\\\n" )
    }
    SetTag( value, tagType, tagKey, "addStr" );
  }
  return { p1: p1, p2: p2 };
}


/**
 * 関数 DelStrPrompt( tagType, tagKey )
 * 「任意の文字列を削除」コマンド
 * 開きカッコと閉じカッコ
 * 入力ダイアログで指定された文字列を返す
 */
function DelStrPrompt( tagType, tagKey ) {
  // 前回使用した文字列があればダイアログの初期値に再利用
  var str1 = str2 = "";
  if ( tagType && ( t = GetTag( tagType, tagKey, "delStr" ) ) ) {
    str1 = t.str1;  str2 = t.str2;
  }
  // 入力ダイアログ
  var msg = "から削除する文字列:\t"
          + "タブ = \\\\\\ｔ  (注:￥記号３つ)";
  p1 = Prompt( "先頭（行頭）" + msg, str1 ).replace( /\\\\\\t/g, "\t" );
  p2 = Prompt( "末尾（行末）" + msg, str2 ).replace( /\\\\\\t/g, "\t" );
  if ( ! p1 && ! p2 ) { return { p1: "",  p2: "" }; }
  if ( tagType ) {
    var value = {
      str1: p1.replace( /\t/g, "\\\\\\t" ),
      str2: p2.replace( /\t/g, "\\\\\\t" )
    }
    SetTag( value, tagType, tagKey, "delStr" );
  }
  return { p1: p1, p2: p2 };
}


/**
 * 関数 DelByNumPrompt()
 * 「任意の文字列を削除」コマンド
 * 入力ダイアログで指定された文字列から
 * 数字を抽出して半角数字にして返す
 */
function DelByNumPrompt() {
  // ダイアログのテキスト入力フィールドから文字列を取得
  var msg = "から削除する文字数 （数字のみ有効）:";
  var p1 = ToHalfWidth( Prompt( "先頭（行頭）" + msg, "" )
           ).replace( /\D/g , "" );	// 半角に変換して数字以外の文字は削除
  var p2 = ToHalfWidth( Prompt( "末尾（行末）" + msg, "" )
           ).replace( /\D/g , "" );	// 半角に変換して数字以外の文字は削除
  return { p1: p1, p2: p2 };
}


/**
 * 関数 MultiFunction( Fn, arg1 )
 * マルチカーソル（複数選択範囲）に対応させる
 * 第１引数: Function; 選択範囲ごとに適用する処理の関数
 * 第２引数以降: Function に渡す引数をまとめた配列
 */
function MultiFunction( Fn, arg ) {
  var d = editor.ActiveDocument;
  var s = d.selection;

  // 矩形選択範囲は行に分ける
  s.Mode = meModeMulti;

  // 選択範囲の座標を取得
  var sCount = s.Count;
  var Sel = [];
  for ( var i = 0; i < sCount; i ++ ) {
    Sel[i] = {
      act: s.GetActivePos( i ),
      anc: s.GetAnchorPos( i )
    };
  }

  // 各選択範囲を処理;
  for ( var i = 0, diff = 0, dl; i < sCount; i ++ ) {
    dl = d.TextLength;
    s.SetActivePos( Sel[i].act + diff );
    s.SetAnchorPos( Sel[i].anc + diff );

    Fn( arg );	// AddBrackets_Main() 関数を実行

    // Fn() の残した選択範囲（またはキャレット位置）を回収
    Sel[i].act = s.GetActivePos();
    Sel[i].anc = s.GetAnchorPos();
    diff += d.TextLength - dl;	// 文字数の増減量（累積）
  }

  // マルチカーソル（複数選択範囲）を復帰
  for ( var i = 0; i < sCount; i ++ ) {
    s.AddPos( Sel[i].anc, Sel[i].act );
  }
}
</syntaxhighlight>