「カッコで囲う」の版間の差分

Sukemaru (トーク | 投稿記録)
修正と更新
Sukemaru (トーク | 投稿記録)
ZIP 書庫更新。マルチカーソルに対応。「カッコで囲う2」を追加
1行目: 1行目:
== ダウンロード ==
== ダウンロード ==


'''全部入りの書庫をダウンロード''' → 「[[ファイル:カッコで囲う.zip|カッコで囲う.zip]](アイコン入り)」 (最終更新 2020/06/03)  
'''ダウンロード''' >> 「[[ファイル:カッコで囲う.zip|カッコで囲う.zip]](アイコン入り)」 (最終更新 2020/06/23)  
 
: <span style="color:#0000c0;">Mery ver 3.0.1 以降のマルチカーソル/複数選択範囲に対応</span>
<br>
: ZIP 書庫には以下のマクロの JS ファイルと、それぞれ専用の "マテリアルデザインっぽい" アイコンがふくまれています。
: ZIP 書庫には以下のマクロの JS ファイルと、それぞれ専用の "マテリアルデザインっぽい" アイコンがふくまれています。
* [[#カッコで囲う(ポップアップメニューあり)|カッコで囲う(ポップアップメニューあり)]]
* [[#カッコで囲う(ポップアップメニューあり)|カッコで囲う(ポップアップメニューあり)]]
* [[#カッコで囲う (ポップアップメニューなし)|カッコで囲う(ポップアップメニューなし)]]
* [[#カッコで囲う (ポップアップメニューなし)|カッコで囲う(ポップアップメニューなし)]]
* [[#引用符を追加/削除|引用符を追加/削除]]
* [[#引用符を追加/削除|引用符を追加/削除]]
* [[#カッコで囲う2(各行ごとにカッコで囲う/Mery ver 3 用)|カッコで囲う2(各行ごとにカッコで囲う/Mery ver 3 用)]]




14行目: 16行目:


== カッコで囲う(ポップアップメニューあり) ==
== カッコで囲う(ポップアップメニューあり) ==
(最終更新 2020/06/03)
(最終更新 2020/06/23)<br>


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


* '''メニュー項目を増やしたいばあいは、'''
* '''メニュー項目を増やしたいばあいは、'''
# ソースコード冒頭の配列 p1, p2 の21番目~30番目に任意の <u> , "記号"</u> を追加する
# ソースコード冒頭の配列 pp1, pp2 の21番目~30番目に任意の <code>"記号"</code> を追加する
# 対応する番号をつけて <u>''"m.Add( "カッコ・記号 の名前" , XX );"''</u> の行を追加する
# 対応する番号をつけて <code>m.Add( "カッコ・記号 の名前" , XX );</code> の行を追加する
# 対応する番号をつけて <u>"case XX:"</u> を適当なグループに追加する
# 対応する番号をつけて <code>case XX:</code> を適当なグループに追加する
 
 
作成にあたり、「'''引用の追加'''」マクロとキーアサイン集の「[[キーアサイン集#括弧で挟む|括弧で挟む]]」マクロのコードを参考にしました(※「引用の追加」マクロは 2018/10/14 付けで公開停止になりました)。




168行目: 167行目:


※選択文字列のある行の '''ひとつしたの行''' に各構文を挿入します。
※選択文字列のある行の '''ひとつしたの行''' に各構文を挿入します。
<br> ※選択範囲が複数行の場合は "'''+ \n +'''" でつなぎ合わせます。
<br> ※選択範囲が複数行の場合は '''+ "\n" +''' でつなぎ合わせます。


* '''アウトプット'''
* '''アウトプット'''
185行目: 184行目:
=== ソースコード ===
=== ソースコード ===


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


194行目: 193行目:
  * -----------------------------------------------------------------------------
  * -----------------------------------------------------------------------------
  * カッコで囲う(ポップアップメニュー)
  * カッコで囲う(ポップアップメニュー)
  * sukemaru, 2018/08/24 - 2020/06/03
  * sukemaru, 2018/08/24 - 2020/06/23
  * -----------------------------------------------------------------------------
  * -----------------------------------------------------------------------------
  * (Last modified: 2020/06/03)
  * (Last modified: 2020/06/23)
  * カッコで囲まれた文字列が2つできてしまう不具合を修正
* マルチカーソル/複数選択範囲に対応
* 入力ダイアログを使用する処理を関数化
* カッコの定義配列の変数名を変更(p1 ⇒ pp1, p1 ⇒ pp1)
* (2020/06/03)
  * カッコで囲まれた文字列が2つできてしまう不具合を修正
  * 処理コード内の一部の変数名を変更
  * 処理コード内の一部の変数名を変更
* (2019/03/28)
* 「JS コメントアウト/アンコメント」を正規表現置換メソッドに変更
* 「任意の 文字数/文字列 を削除」を追加
* 「行頭/行末の空白を削除」を追加
* 「1文字ずつ前後を削除(外)」を追加
* 「ひとつ削除」を追加(「カッコをはずす」マクロから転用)
* 「アウトプット/アラート/コンファーム/ステータス」を追加
* 「カッコの定義」を使わないコマンドの ID を 1030~ に変更
* サブメニューを追加してネスト化
  * -----------------------------------------------------------------------------
  * -----------------------------------------------------------------------------
*
* ポップアップメニューからカッコの種類を選択して、選択範囲をカッコで囲う。
* 公式 wiki のマクロライブラリより「引用の追加」と「括弧で挟む」のコードを参考にした
*
* ・複数行の選択範囲で末尾が改行 \n のとき、さいごの改行は除外する。
* ・非選択時には、それぞれことなる動作をする。
*
* ※ 「任意の文字列」について ※
* ・「任意の文字列1」は選択範囲全体をひとくくりに、
*  「任意の文字列2」は選択範囲内の "各行ごと" で個別に、指定した文字列で前後を囲う。
* ・wiki 文字装飾タグ以外のカッコで "各行ごと" に囲いたい場合は、「任意の文字列2」を使用する。
* ・文字コードでの入力には非対応(入力されたままの文字列を返す)。
* ・改行コードとタブ文字は、それぞれ「\\\n」と「\\\t」で入力されたものを置換する。
*  パスの入力に配慮しただけの簡易的な置換処理なので、「\」を4つ以上かさねた場合を考慮していない。
*
* ※ 「wiki 文字装飾タグ」について ※
* ・選択範囲内の "各行ごと" で個別に、指定したタグで前後を囲う。
* ・空行にもマークアップタグを挿入する場合は、skip オプションを無効にすること。
*
* ※ JS/XML コメントアウト と アンコメント について ※
* ・「カッコで囲う」マクロでは行の中間部分だけをコメントアウトするので、
*  行単位でコメントアウトするなら「引用の追加」マクロが適する。
* ・「カッコで囲う」マクロでは行の先頭部分のコメントマークだけにしかマッチしないので、
*  コメント部分がインデント(字下げ)されている場合も「引用の追加」マクロが適する。
* ・ほかにも注意事項があるので、該当コード部分の注意書きを参照のこと。
*
* ※ 「ひとつ削除」について ※
* ・「開きカッコ」「閉じカッコ」の定義とは別に削除用の定義を使用して、
*  選択範囲の先頭と末尾の1組の「カッコ」を削除する。
*  各種カッコ、引用符のほかにも各種の記号のペア、半角空白などを削除対象とする。
*
* ※ 削除系のコマンドについて ※
* ・選択範囲がないときはポップアップメニュー上に表示しない。
*
* -----------------------------------------------------------------------------
* ※ ポップアップメニューの項目は、m.Add( … ); の不要な行を行をコメントアウトすれば隠せる。
* (配列から削除する場合は中身だけ消して  ""  として空要素を残しておかないと
*  メニューや処理コードの ID と一致しなくなる)
*
  */
  */


255行目: 210行目:
var skip = true; // (true; スキップする / false; スキップしない)
var skip = true; // (true; スキップする / false; スキップしない)


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


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


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


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


var s = editor.ActiveDocument.selection


// ポップアップメニュー項目の定義
var m = CreatePopupMenu();
var m = CreatePopupMenu(),
var d = editor.ActiveDocument;
  sm1 = CreatePopupMenu(),
if ( d.ReadOnly ) {
   sm2 = CreatePopupMenu(),
   m.Add( " ドキュメントは 書き換え禁止 です & ", 0 );
   sm3 = CreatePopupMenu();
}
var grayFlag = s.Text ? 0 : meMenuGrayed;
 
else {
   var s = editor.ActiveDocument.selection;
  var grayFlag = s.Text ? 0 : meMenuGrayed;
 
   // m.Add( "ラベル", r ); の各行は、任意に上下移動(並べ替え)してよいが、
   // m.Add( "ラベル", r ); の各行は、任意に上下移動(並べ替え)してよいが、
   // r の数値は上の配列の並び順やテキスト変換処理の case r: に対応しているので変更しないこと!
   // r の数値は上の配列の並び順やテキスト変換処理の case r: に対応しているので変更しないこと!


/* 入力 ダイアログ */
  /* 入力 ダイアログ */
m.Add( "任意の文字列 で前後を囲う (&E) ...", 1050 );   // Enter the custom string(s)
  m.Add( "任意の文字列 で前後を囲う (&E) ...", 1050 ); // Enter the custom string(s)
m.Add( "任意の文字列 2 (&E) ...", 1051 ); // 各行ごとに指定文字列で囲う(skip フラグを指定すること)
  m.Add( "任意の文字列 2 (各行) (&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文字ずつ前後を削除 ◀  (1)", 1031 );
      sm1.Add( " ▶ &2文字ずつ前後を削除 ◀  (2)", 1032 );
      sm1.Add( " ▶ &3文字ずつ前後を削除 ◀  (3)", 1033 );
  }


/* 削除系コマンド */
  /* カッコ */
if ( s.Text ) { // 選択範囲がないときは表示しない
   m.Add( "", 0, meMenuSeparator );
   m.Add( "", 0, meMenuSeparator );
   m.Add( "▲ ひとつ削除 (&1)", 1038 );
   m.Add( " ( 半角 小カッコ )  (&P)", 1 );       // Parenthesis
   m.AddPopup( "● 削除 (&T)", sm1 );
   m.Add( "", 0, meMenuSeparator );
    sm1.Add( "  先頭/末尾から任意の 文字列 を削除 (各行) (&Z) ...", 1053 );
  m.Add( "< 半角 山カッコ > (&A)", 2 );         // Angle brackets
    sm1.Add( "  先頭/末尾から任意の 文字数 を削除 (各行) (&X) ...", 1052 );
  m.Add( " [ 半角 大カッコ ]  (&B)", 3 );       // square Brackets
    sm1.Add( "", 0, meMenuSeparator );
  m.Add( " { 半角 中カッコ } (&C)", 4 );       // Curly brackets
    sm1.Add( "≫ 先頭/末尾から 空白 を削除 ≪ (各行) (&W)", 1037 );
    sm1.Add( "≫ 先頭の 空白 を削除   (各行) (&T)", 1035 );
    sm1.Add( "  末尾の 空白 を削除 ≪ (各行) (&B)", 1036 );
    sm1.Add( "", 0, meMenuSeparator );
    sm1.Add( "◀  1文字ずつ 前後を削除  ▶ (外側) (&0)", 1034 );
    sm1.Add( " ▶ &1文字ずつ前後を削除 ◀  (1)", 1031 );
    sm1.Add( " ▶ &2文字ずつ前後を削除 ◀ (2)", 1032 );
    sm1.Add( " ▶ &3文字ずつ前後を削除 ◀  (3)", 1033 );
}


/* カッコ */
  m.Add( "", 0, meMenuSeparator );
m.Add( "", 0, meMenuSeparator );
  m.Add( "( 全角 小カッコ ) (&R)", 5 );       // Round brackets
m.Add( " ( 半角 小カッコ )  (&P)", 1 ); // Parenthesis
  m.Add( "", 0, meMenuSeparator );
m.Add( "", 0, meMenuSeparator );
  m.Add( "「 全角 かぎカッコ 」 (&K)", 6 );     // Kakko
m.Add( "< 半角 山カッコ > (&A)", 2 ); // Angle brackets
  m.Add( "『 全角 二重かぎカッコ 』 (&W)", 7 ); // White corner brackets
m.Add( " [ 半角 大カッコ ]  (&B)", 3 ); // square Brackets
  m.Add( "【 全角 スミ付きカッコ 】 (&L)", 8 ); // Lenticular brackets
m.Add( " { 半角 中カッコ }  (&C)", 4 ); // Curly brackets


m.Add( "", 0, meMenuSeparator );
  m.Add( "", 0, meMenuSeparator );
m.Add( "( 全角 小カッコ ) (&R)", 5 );     // Round brackets
  m.Add( "␣( 全角 小カッコ )␣ (&F)", 9 );     // Full width parenthesis (w/ space)
m.Add( "", 0, meMenuSeparator );
  m.Add( "␣ ( 半角 小カッコ ) ␣ (&H)", 10 );   // Half-width parenthesis (w/ space)
m.Add( "「 全角 かぎカッコ 」 (&K)", 6 );   // Kakko
  m.Add( '␣ "  半角 引用符  " ␣ (&Q)', 11 );   // double-Quotation mark (w/ space)
m.Add( "『 全角 二重かぎカッコ 』 (&W)", 7 ); // White corner brackets
  m.Add( "␣  半角 スペース  ␣ (&S)", 12 );     // Space
m.Add( "【 全角 スミ付きカッコ 】 (&L)", 8 ); // Lenticular brackets


m.Add( "", 0, meMenuSeparator );
  m.Add( "", 0, meMenuSeparator );
m.Add( "␣( 全角 小カッコ )␣ (&F)", 9 ); // Full width parenthesis (w/ space)
  m.Add( " -  半角 ハイフン  -  (&-)", 13 );   // hyphen-minus  (w/ spaces)
m.Add( "␣ ( 半角 小カッコ ) ␣ (&H)", 10 ); // Half-width parenthesis (w/ space)
  m.Add( "―― 全角 ダッシュ ―― (&D)", 14 );     // Dash
m.Add( '␣ "  半角 引用符  " ␣ (&Q)', 11 ); // double-Quotation mark (w/ space)
  m.Add( "~ 全角 チルダ ~ (&T)", 15 );           // Tilde
m.Add( "␣ 半角 スペース ␣ (&S)", 12 ); // Space


m.Add( "", 0, meMenuSeparator );
  /* JS コメントアウト / XML コメントアウト */
m.Add( "  -  半角 ハイフン  -   (&-)", 13 ); // hyphen-minus (w/ spaces)
//  m.Add( "", 0, meMenuSeparator );
m.Add( "―― 全角 ダッシュ ―― (&D)", 14 ); // Dash
//  m.Add( "/* * JS コメントアウト 2  */ (&J)", 1041 );  // JavaScript comment out (block comment)
m.Add( "~ 全角 チルダ ~ (&T)", 15 );       // Tilde
//   m.Add( "/*  JS コメントアウト 1  */ (&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


/* JS コメントアウト / XML コメントアウト */
  /* wiki マークアップ
// m.Add( "", 0, meMenuSeparator );
    このブロックの項目は、複数行を選択しているとき「選択範囲の各行ごとに囲う」処理をおこなう
// m.Add( "/* *  JS コメントアウト 2  */ (&J)", 1041 ); // JavaScript comment out (block comment)
    ※ skip フラグを指定すること */
// m.Add( "/* JS コメントアウト 1 */ (&V)", 1042 ); // jaVascript comment out
//   m.Add( "", 0, meMenuSeparator );
// m.Add( "▲ JS アンコメント (&U)", 1043, grayFlag ); // Uncomment
//   m.AddPopup( "wiki 文字修飾 (各行) (&W)", sm2 = CreatePopupMenu() );
// m.Add( "", 0, meMenuSeparator );
//     sm2.Add( "'''  wiki 太字 ''' (&B)", 16 );     // Bold
// m.Add( "<!--  XML コメントアウト --> (&X)", 1044 ); // Xml comment out
//     sm2.Add( "''  wiki 斜体  ''  ( &I )", 17 );   // Italic
// m.Add( "▲ XML アンコメント (&M)", 1045, grayFlag ); // xMl uncomment
//     sm2.Add( "<u> wiki 下線 </u>  (&U)", 18 );       // Under line
//     sm2.Add( "[[  wiki リンク  ]] (&L)", 19 );   // Link
//     sm2.Add( "<nowiki>  </nowiki>  (&N)", 20 );     // Nowiki


/* wiki マークアップ
   /* Mery マクロ用
  このブロックの項目は、複数行を選択しているとき「選択範囲の各行ごとに囲う」処理をおこなう
    以下の項目は、選択範囲の文字列をコピーして、一行下でそれぞれの構文で囲う */
  (※ skip フラグを指定すること) */
//   m.Add( "", 0, meMenuSeparator );
// m.Add( "", 0, meMenuSeparator );
//   m.AddPopup( "Mery マクロ (&Y)", sm3 = CreatePopupMenu() );
// m.AddPopup( "wiki 文字修飾 (&W)", sm2 );
//     sm3.Add( "アウトプット (&O)", 1060 );       // OutputBar.Writeln( ... )
//  sm2.Add( "''' wiki 太字 '''  (&B)", 16 );  // Bold
//     sm3.Add( "アラート (&A)", 1061 );           // Alert( ... )
//  sm2.Add( "''  wiki 斜体  ''  ( &I )", 17 ); // Italic
//     sm3.Add( "コンファーム (&C)", 1062 );       // Confirm( ... )
//  sm2.Add( "<u> wiki 下線 </u>  (&U)", 18 );  // Under line
//     sm3.Add( "ステータス (&S)", 1063 );         // Status = ...
//   sm2.Add( "[[  wiki リンク  ]]  (&L)", 19 ); // Link
//  sm2.Add( "<nowiki> </nowiki>  (&N)", 20 );      // Nowiki
 
/* Mery マクロ用
  以下の項目は、選択範囲の文字列をコピーして、一行下でそれぞれの構文で囲う */  
// m.Add( "", 0, meMenuSeparator );
// m.AddPopup( "Mery マクロ (&Y)", sm3 );
//   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 ); // Escキー でキャンセルできるのでアクセラレータなし


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


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


if ( r > 0 ) {
if ( r > 0 ) {
   Redraw = false;
   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 ];
    // 選択範囲が1つで矩形選択ではないとき
    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 anc = s.GetAnchorPos(),  act = s.GetActivePos();
   var tp = ( anc < act ) ? anc : act; // 選択範囲の先頭位置
   var tp = ( anc < act ) ? anc : act;
   var bp = ( anc < act ) ? act : anc; // 選択範囲の末尾位置
   var bp = ( anc < act ) ? act : anc;
 
   // 選択範囲がなければカーソル位置を取得
   // 選択範囲がなければカーソル位置を取得
   if ( s.IsEmpty ) {
   if ( s.IsEmpty ) {
     var pos = s.GetActivePos();
     var pos = s.GetActivePos();
   }
   }
  // マクロ実行前の選択範囲の各座標を取得
   var tx = s.GetTopPointX( mePosLogical );
   var tx = s.GetTopPointX( mePosLogical );
   var ty = s.GetTopPointY( mePosLogical );
   var ty = s.GetTopPointY( mePosLogical );
   var bx = s.GetBottomPointX( mePosLogical );
   var bx = s.GetBottomPointX( mePosLogical );
   var by = s.GetBottomPointY( mePosLogical );
   var by = s.GetBottomPointY( mePosLogical );
   // 選択範囲の末尾位置を調整(最後の \n を含めない)
   // 選択範囲の末尾位置を調整(最後の \n を含めない)
   // ※ { 中カッコ } のばあいは末尾の調整をしない
   // ※ { 中カッコ } のばあいは末尾の調整をしない
402行目: 419行目:
   case 21:  case 22:  case 23:  case 24:  case 25:
   case 21:  case 22:  case 23:  case 24:  case 25:
     // カッコ p1 & p2 で囲う
     // カッコ p1 & p2 で囲う
     s.Text = p1[r] + st + p2[r];
     s.Text = p1 + st + p2;
 
    // 選択範囲があれば選択範囲を復元
     if ( pos ) { // 選択範囲がなければカーソルをカッコのなかに移動
     if ( st ) { s.SetAnchorPos( tp ); }
      s.SetActivePos( pos + p1[r].length );
     // 選択範囲がなければカーソルをカッコのなかに移動
     }
     else { s.SetActivePos( pos + p1.length ); }
     else { // 選択範囲があれば選択範囲を復元
      s.SetAnchorPos( tp );
    }
     break;
     break;


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


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


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


   // n文字ずつ前後を削除(内)
   // n文字ずつ前後を削除(内)
   case 1031:  case 1032:  case 1033:
   case 1031:  case 1032:  case 1033:
     if ( st ) { // 選択範囲があれば
     if ( st ) {
       // 選択範囲の両端から n 文字ずつ消す
       // 選択範囲の両端から n 文字ずつ消す
       var n = ( r - 1030 );
       var n = ( r - 1030 );
481行目: 493行目:
     }
     }
     break;
     break;


   // 1文字ずつ前後を削除(外)
   // 1文字ずつ前後を削除(外)
490行目: 501行目:
     s.SetAnchorPos( tp - 1 ); // 選択範囲を復帰する
     s.SetAnchorPos( tp - 1 ); // 選択範囲を復帰する
     break;
     break;


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


       // 選択範囲に指定文字列がなかった場合 undo 履歴を残さない
       // 選択範囲に指定文字列がなかった場合 undo 履歴を残さない
506行目: 516行目:
     }
     }
     break;
     break;


   // ひとつ削除 (※「カッコをはずす」マクロのコードを流用)
   // ひとつ削除 (※「カッコをはずす」マクロのコードを流用)
   case 1038:
   case 1038:
     // 「ひとつ削除」用のカッコの定義
     // 「ひとつ削除」用のカッコの定義
     var brackets = ""
     var brackets = " ()「」<>[]{}\"\"''"
    + "()「」<>[]{}\"\"''()「」『』<>[]{}【】〖〗⦅⦆⦅⦆〚〛〔〕〘〙〈〉《》"
    + "()「」『』<>[]{}【】〖〗⦅⦆⦅⦆〚〛〔〕〘〙〈〉《》"
     + "””’’〝〞〝〟‘’“”――~~〜〜 "
     + "””’’〝〞〝〟‘’“”――~~〜〜"
     + "++--**\/\/##==%%::::@@@@※※††||……␣␣__"
     + "++--**\/\/##==%%::::@@@@※※††||……␣␣__"
     + "○○●●□□■■◇◇◆◆▽▽▼▼△△▲▲☆☆★★"
     + "○○●●□□■■◇◇◆◆▽▽▼▼△△▲▲☆☆★★"
527行目: 536行目:
       "'''''", "'''''" , "'''", "'''" , "''", "''" , "[[", "]]" ,   
       "'''''", "'''''" , "'''", "'''" , "''", "''" , "[[", "]]" ,   
       "<nowiki>", "</nowiki>" , "<span>", "</span>" , "<div>", "</div>" ,  
       "<nowiki>", "</nowiki>" , "<span>", "</span>" , "<div>", "</div>" ,  
       "<pre>", "</pre>" , "<source lang=\"javascript\">", "<\/source>"  
       "<pre>", "</pre>" , "<source lang=\"javascript\">", "</source>"  
     ];
     ];
     brackets = brackets2.concat( brackets.split( "" ) );
     brackets = brackets2.concat( brackets.split( "" ) );
540行目: 549行目:
     }
     }
     break;
     break;


   // /* * JavaScriptコメントアウト 2 */
   // /* * JavaScriptコメントアウト 2 */
   case 1041:
   case 1041:
/*
/*
*  基本的に1行めが行の先頭から始まることしか想定していないので、
*  基本的に1行めが行の先頭から始まることしか想定していないので、
*  あらかじめコメントアウトする文字列は、行単位でまとまったブロックにしておくとよい。
*  あらかじめコメントアウトする文字列は、行単位でまとまったブロックにしておくとよい。
*  選択範囲の先頭/末尾が行の途中にある状態でコメントアウトする場合は、改行を追加する。
*  選択範囲の先頭/末尾が行の途中にある状態でコメントアウトする場合は、改行を追加する。
*/
*/
     var p1 = ( tx > 1 ) ? "\n/*\n" : "/*\n"; // */
 
     var p2 = ( document.Text.charAt( bp ) != "\n" ) ? "\n */\n" : "\n */";
     p1 = ( tx > 1 ) ? "\n/\*\n" : "/\*\n";
     p2 = ( document.Text.charAt( bp ) != "\n" ) ? "\n */\n" : "\n */";
     var ast = " * ";
     var ast = " * ";
     // 選択範囲の先頭座標が x = 1 でなければ改行させるので選択範囲の復元用座標を調整
     // 選択範囲の先頭座標が x = 1 でなければ改行させるので選択範囲の復元用座標を調整
560行目: 569行目:
     s.Text = p1 + st.replace( /^(.*)$/gm, ast + "$1" ) + p2;
     s.Text = p1 + st.replace( /^(.*)$/gm, ast + "$1" ) + p2;


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


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


   // JS アンコメント:
   // JS アンコメント:
600行目: 600行目:
  * ・JSコメントでない箇条書き文で実行した場合も行頭のビュレット「* ・ ・」を削除する。
  * ・JSコメントでない箇条書き文で実行した場合も行頭のビュレット「* ・ ・」を削除する。
  */
  */
/* このタイプのコメントにたいしてもアンコメント処理する。 */
/* このタイプのコメントにたいしてもアンコメント処理する。 */


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


   // 任意の文字列を追加 ※テキストボックス
   // 任意の文字列を追加 ※テキストボックス
   case 1050:  case 1051:
   case 1050:  case 1051:
    // 文字コードでの入力には非対応
    // ダイアログのテキスト入力フィールドから文字列を取得
    var msg = "につける文字列:\t改行=\\\\\\n ; タブ=\\\\\\t  (注:¥記号3つ)";
    var p1 = Prompt( "前" + msg, "" )
            .replace( /\\\\\\n/g, "\n" ).replace( /\\\\\\t/g, "\t" );
    var p2 = Prompt( "後ろ" + msg, "" )
            .replace( /\\\\\\n/g, "\n" ).replace( /\\\\\\t/g, "\t" );
     if ( p1 || p2 ) {
     if ( p1 || p2 ) {
       if ( pos ) { // 選択範囲がなければ p1 & p2 を挿入
       if ( st ) {
        s.Text = p1 + p2;
        // 「任意の文字列1」 選択範囲全体を p1 & p2 で囲う
        s.SetActivePos( pos + p1.length ); // カーソルをカッコのなかに移動
      }
      else { // 選択範囲があれば
        // 「任意の文字列1」
         if ( r == 1050 ) {
         if ( r == 1050 ) {
          //  選択範囲全体を p1 & p2 で囲う
           s.Text = p1 + st + p2;
           s.Text = p1 + st + p2;
         }
         }
         // 「任意の文字列2」
         // 「任意の文字列2」 選択範囲の各行を p1 & p2 で囲う
         else {
         else {
          // 選択範囲の各行を p1 & p2 で囲う
           tmp = AddBrackets( st, p1, p2, skip );
           tmp = AddBrackets( st, p1, p2, pos, skip );
           if ( tmp != st ) { s.Text = tmp; }
           if ( tmp != st ) { s.Text = tmp; }
          // テキストに変更なし
           else { s.SetActivePos( bp ); }
           else { s.SetActivePos( bp ); }
         }
         }
         s.SetAnchorPos( tp ); // 選択範囲を復元
         s.SetAnchorPos( tp ); // 選択範囲を復元
      }
      // 選択範囲がなければ p1 & p2 を挿入し、カーソルをカッコのなかに移動
      else {
        s.Text = p1 + p2;
        s.SetActivePos( pos + p1.length );
       }
       }
     }
     }
     break;
     break;


   // 各行の前後から任意の文字数/文字列を削除 ※テキストボックス
   // 各行の前後から任意の文字数/文字列を削除 ※テキストボックス
   case 1052:  case 1053:
   case 1052:  case 1053:
     if ( ! pos ) { // 選択範囲があれば
     if ( st ) {
      var msg, p1, p2;
       // 「任意の文字数を削除」 各行の先頭/末尾から指定文字数を削除
 
       if ( r == 1053 ) {
       // 「任意の 文字数 を削除」
       if ( r == 1052 ) {
        // ダイアログのテキスト入力フィールドから文字列を取得
        // ※ 半角に変換して数字以外の文字は削除
        msg = "から削除する文字数 (数字のみ有効):";
        p1 = ToHalfWidth( Prompt( "先頭(行頭)" + msg, "" ) )
            .replace( /[^0-9]/g, "" );
        p2 = ToHalfWidth( Prompt( "末尾(行末)" + msg, "" ) )
            .replace( /[^0-9]/g, "" );
        // 各行の先頭/末尾から指定文字数を削除
         tmp = DeleteCharByNum( st, p1, p2 );
         tmp = DeleteCharByNum( st, p1, p2 );
       }
       }
 
       // 「任意の文字列を削除」 各行の先頭/末尾の指定文字列を削除
       // 「任意の 文字列 を削除」
       else { // ( r == 1052 )
       else {
         var reg = new RegExp(
        // ダイアログのテキスト入力フィールドから文字列を取得
          "^" + p1.replace( /[.*+?^=!:${}()|[\]\/\\]/g, "\\$&" )
        msg = "から削除する文字列:\tタブ = \\\\\\t  (¥記号3つ)";
         + "|" + p2.replace( /[.*+?^=!:${}()|[\]\/\\]/g, "\\$&" ) + "$"
         p1 = Prompt( "先頭(行頭)" + msg, "" )
        , "gm" );
            .replace( /\\\\\\t/g, "\t" );
         p2 = Prompt( "末尾(行末)" + msg, "" )
            .replace( /\\\\\\t/g, "\t" );
        // 各行の先頭/末尾の指定文字列を削除
        var reg = new RegExp( "^" + Quote( p1 ) + "|" + Quote( p2 ) + "$", "gm" );
         tmp = st.replace( reg , "" );
         tmp = st.replace( reg , "" );
       }
       }
       // 選択範囲に指定文字列がなかった場合 undo 履歴を残さない
       // 選択範囲に指定文字列がなかった場合 undo 履歴を残さない
       if ( tmp != st ) {
       if ( tmp != st ) {
706行目: 679行目:
     }
     }
     break;
     break;


   // アウトプット / アラート / コンファーム / ステータス
   // アウトプット / アラート / コンファーム / ステータス
724行目: 696行目:
     tmp = '"' + st.replace( /\n/g, '" + "\\n" + "' ) + '"';
     tmp = '"' + st.replace( /\n/g, '" + "\\n" + "' ) + '"';
     var sur = ( ( r == 1063 ) ? ";" : " );" ) + "\n";
     var sur = ( ( r == 1063 ) ? ";" : " );" ) + "\n";
     s.Text = ( ( r == 1060 ) ? "OutputBar.Writeln( " :
     s.Text = ( ( r == 1060 ) ? "OutputBar.Writeln( " :
              ( r == 1061 ) ? "Alert( " :
                ( r == 1061 ) ? "Alert( " :
              ( r == 1062 ) ? "Confirm( " :
                ( r == 1062 ) ? "Confirm( " :
              /* r == 1063 */  "Status = "
              /* r == 1063 */  "Status = "
            ) + tmp + sur;
              ) + tmp + sur;
     // カッコの中の文字列を範囲選択する
     // カッコの中の文字列を範囲選択する
     s.SetActivePos( s.GetActivePos() - sur.length );
     s.SetActivePos( s.GetActivePos() - sur.length );
738行目: 710行目:
     }
     }
     break;
     break;


   default:
   default:
744行目: 715行目:
   }
   }
}
}
Redraw = true;




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




/* 関数 AddWikiLink() */
/* 関数 AddWikiLink( str, p1, p2 skip ) */
function AddWikiLink( str, p1, p2, pos, skip ) {
function AddWikiLink( str, p1, p2, skip ) {
   var a = str.split( "\n" ); // 選択範囲 st を "\n" で区切って配列 a に
   var a = str.split( "\n" ); // 選択範囲 st を "\n" で区切って配列 a に
   for ( var i = 0, len = a.length; i < len; i ++ ) {
   for ( var i = 0, len = a.length; i < len; i ++ ) {
     // skip = true のときは、空白行をスキップ
     // skip = true のときは、空白行をスキップ
     if ( ! pos && skip && /^\s*$/.test( a[i] ) ) {
     if ( str && skip && /^\s*$/.test( a[i] ) ) { continue; }
      continue;
    }
     // 空行には全角スペースつきではさむ
     // 空行には全角スペースつきではさむ
     var bar = ( pos || ! a[i].length ) ? " | " : "|" ;
     var bar = ( ! str || ! a[i].length ) ? " | " : "|" ;
     a[i] =  p1 + a[i] + bar + a[i] + p2; // 各行を [[str|str]] に置換
     a[i] =  p1 + a[i] + bar + a[i] + p2; // 各行を [[str|str]] に置換
   }
   }
800行目: 762行目:
   // ループ処理で「対になるカッコ」と一致するかチェック
   // ループ処理で「対になるカッコ」と一致するかチェック
   for ( var i = 0, len = brackets.length; i < len; i ++ ) {
   for ( var i = 0, len = brackets.length; i < len; i ++ ) {
     if ( i % 2 == 1 || ! brackets[i].length ) {
     if ( i % 2 == 1 || ! brackets[i].length ) { continue; }
      continue;
    }
     var o = brackets[ i ]; // 開きカッコ
     var o = brackets[ i ]; // 開きカッコ
     var c = brackets[ i + 1 ]; // 閉じカッコ
     var c = brackets[ i + 1 ]; // 閉じカッコ
813行目: 773行目:
       break;
       break;
     }
     }
   } // end for
   }
   return str;
   return str;
}
}




/* 関数 quote( str ) */
/**
// ref. 『正規表現 - JavaScript | MDN』
* 関数 ToHalfWidth( strVal )
// https://developer.mozilla.org/ja/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
* 全角英数記号を半角変換して返す
function Quote( str ) {
*/
   return str.replace( /[.*+?^=!:${}()|[\]\/\\]/g, "\\$&" );  
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"
          + "改行 = \\\\\\n ; タブ = \\\\\\t  (注:¥記号3つ)";
   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 };
}




/**
/**
  * 全角から半角への変革関数 toHalfWidth( strVal )
  * 関数 DelStrPrompt( tagType, tagKey )
  * 入力値の英数記号を半角変換して返却
  * 「任意の文字列を削除」コマンド
  * [引数]  strVal: 入力値
  * 開きカッコと閉じカッコ
  * [返却値] String(): 半角変換された文字列
  * 入力ダイアログで指定された文字列を返す
  */
  */
// https://webllica.com/add-comma-as-thousands-separator/ より
function DelStrPrompt( tagType, tagKey ) {
function ToHalfWidth( strVal ){
  // 前回使用した文字列があればダイアログの初期値に再利用
   var halfVal = strVal.replace( /[!-~]/g, function( tmp ) {
  var str1 = str2 = "";
     // 文字コードをシフト
  if ( tagType && ( t = GetTag( tagType, tagKey, "delStr" ) ) ) {
     return String.fromCharCode( tmp.charCodeAt(0) - 0xFEE0 );
    str1 = t.str1;  str2 = t.str2;
   } );
  }
   return halfVal;
  // 入力ダイアログ
  var msg = "から削除する文字列:\t"
          + "タブ = \\\\\\t  (注:¥記号3つ)";
  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 };
}
}




// -----------------------------------------------------------------------------
/**
// 以下の2つの関数は破棄してよいかも
  * 関数 DelByNumPrompt()
// (switch - case 文の中で replace メソッドでの置換処理に変更した)
  * 「任意の文字列を削除」コマンド
// -----------------------------------------------------------------------------
* 入力ダイアログで指定された文字列から
/*  
* 数字を抽出して半角数字にして返す
  * 関数 CommentOutJS()
  * このかたちにコメントアウトする
  */
  */
function CommentOutJS( str, p1, p2, ast ) {
function DelByNumPrompt() {
   var a = str.split( "\n" ); // 選択範囲 st を "\n" で区切って配列 a に
  // ダイアログのテキスト入力フィールドから文字列を取得
   for ( var i = 0, len = a.length; i < len; i ++ )
   var msg = "から削除する文字数 (数字のみ有効):";
    a[i] = ast + a[i]; // 各行の先頭に " * " を追加する
   var p1 = ToHalfWidth( Prompt( "先頭(行頭)" + msg, "" )
   // 各行を "\n" で区切って連結し、先頭に "/*\n"、末尾に "\n */" を追加する
          ).replace( /\D/g , "" ); // 半角に変換して数字以外の文字は削除
   return p1 + a.join( "\n" ) + p2;
   var p2 = ToHalfWidth( Prompt( "末尾(行末)" + msg, "" )
          ).replace( /\D/g , "" ); // 半角に変換して数字以外の文字は削除
   return { p1: p1, p2: p2 };
}
}




/*  
/**
  * 関数 UnCommentJS( str )  
  * 関数 MultiFunction( Fn, arg1 )
  * 基本的にこのかたちのコメントブロックしか想定していない(インデントには非対応)。
  * マルチカーソル(複数選択範囲)に対応させる
  * また、複数のコメントブロックがある場合を想定していない。
  * 第1引数: Function; 選択範囲ごとに適用する処理の関数
  * 中間行の行頭記号はアスタリスク「*」と中黒「・」「・」を削除対象とする。
  * 第2引数以降: Function に渡す引数をまとめた配列
  */  
  */
function UnCommentJS( str ) {
function MultiFunction( Fn, arg ) {
   var re1 = "^ ?\\/\\*+ ?\\n?"; // 先頭行のコメントマークの正規表現
   var d = editor.ActiveDocument;
   var re2 = "\\n? ?\\*+\\/ ?$"; // 末行のコメントマークの正規表現
  var s = d.selection;
   var reg = new RegExp( re1 + "|" + re2 , "g" ); // 正規表現オブジェクトに変換
 
   var re3 = /^ ?(\*+|[・・]) ?/; // 中間行の行頭記号の正規表現
  // 矩形選択範囲は行に分ける
  var a = str.split( "\n" ); // 選択範囲 st を "\n" で区切って配列 a に
  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() の残した選択範囲(またはキャレット位置)を回収
  for ( var i = 0, len = a.length; i < len; i ++ ) {
     Sel[i].act = s.GetActivePos();
    // 先頭行と末行のコメントマークがある行はスキップ
     Sel[i].anc = s.GetAnchorPos();
     if ( reg.test( a[i] ) ) { continue; }
    diff += d.TextLength - dl; // 文字数の増減量(累積)
    // 中間行の行頭記号を削除
     a[i] = a[i].replace( re3 , "" );
   }
   }


   // 各行を "\n" で区切って連結し、先頭行と末行のコメントマークを削除
   // マルチカーソル(複数選択範囲)を復帰
   return a.join( "\n" ).replace( reg , "" );
   for ( var i = 0; i < sCount; i ++ ) {
    s.AddPos( Sel[i].anc, Sel[i].act );
  }
}
}
</source>
</syntaxhighlight>
<br>
<br>




== カッコで囲う (ポップアップメニューなし) ==
== カッコで囲う (ポップアップメニューなし) ==
(最終更新 2020/06/03)
(最終更新 2020/06/23)


簡易版です。 <br>
簡易版です。 <br>
897行目: 968行目:
また、マクロ実行後のカーソル位置を'''選択範囲なし'''のときと'''選択範囲あり'''のときとで変えたいばあいも、こちらのコードがよいでしょう。
また、マクロ実行後のカーソル位置を'''選択範囲なし'''のときと'''選択範囲あり'''のときとで変えたいばあいも、こちらのコードがよいでしょう。


<source lang="javascript">
<source lang="javascript" style="height:80em; overflow:auto;">
#title = "( カッコ )"
#title = "( カッコ )"
#tooltip = "( カッコ ) で囲う"
#tooltip = "( カッコ ) で囲う"
// #icon = "brackets(parenthesis).ico"
#icon = "brackets(parenthesis).ico"
// #icon = "Mery用 マテリアルデザインっぽいアイコン.icl",101
// #icon = "Mery用 マテリアルデザインっぽいアイコン.icl",101


// MeryWiki の マクロライブラリ >> キーアサイン集 の「括弧で挟む」を改変
/**
// 選択範囲の前後に任意の文字列(複数文字)を追加するマクロとしても利用できます
* -----------------------------------------------------------------------------
* カッコで囲う
* sukemaru (Last modified: 2020/06/23)
* -----------------------------------------------------------------------------
* MeryWiki の マクロライブラリ >> キーアサイン集 の「括弧で挟む」を改変
* 選択範囲の前後に任意の文字列(複数文字)を追加するマクロとして利用できます
*
* マルチカーソル/複数選択範囲に対応
*/


// ---------- ▼ 設定項目 ▼ ---------- //
// ---------- ▼ 設定項目 ▼ ---------- //
914行目: 993行目:




// 選択範囲の各座標を取得
var s = editor.ActiveDocument.selection;
var s = editor.ActiveDocument.selection;
var ax = s.GetTopPointX( mePosLogical );
var sx = ScrollX,  sy = ScrollY;
var ay = s.GetTopPointY( mePosLogical );
 
// マルチカーソル対応
var arg = [ pre, sur ];
// 選択範囲が1つで矩形選択ではないとき
if ( ! s.Mode || s.Mode === meModeStream ) {
  Brackets_Main( arg );
}
// 複数行または複数選択のとき
else {
  BeginUndoGroup();
  AddUndo();
  MultiFunction( Brackets_Main, arg );
  EndUndoGroup();
}
ScrollX = sx;  ScrollY = sy;
 
 
function Brackets_Main( arg ) {
  var pre = arg[0];
  var sur = arg[1];
 
  // 選択範囲の各座標を取得
  var s = editor.ActiveDocument.selection;
  var tx = s.GetTopPointX( mePosLogical );
  var ty = s.GetTopPointY( mePosLogical );


// 選択範囲のテキストを取得し、カッコを追加
  // 選択範囲のテキストを取得し、カッコを追加
var st = s.Text;
  var st = s.Text;
s.Text = pre + st + sur;
  s.Text = pre + st + sur;


// カーソルを移動、または範囲選択
  // カーソルを移動、または範囲選択
if ( ! st ) {
  if ( ! st ) {
  // 選択範囲なしだったばあい、カッコのあいだにカーソルを移動
    // 選択範囲なしだったばあい、カッコのあいだにカーソルを移動
  s.SetActivePos( s.GetActivePos() - sur.length );
    s.SetActivePos( s.GetActivePos() - sur.length );
  }
  else {
    // 選択範囲があったばあい、カッコを含めて範囲選択
    s.SetAnchorPoint( mePosLogical, tx, ty );
  }
}
}
else {
 
   // 選択範囲があったばあい、カッコを含めて範囲選択
 
   s.SetAnchorPoint( mePosLogical, ax, ay );
/**
* 関数 MultiFunction( Fn, arg1 )
* マルチカーソル(複数選択範囲)に対応させる
* 第1引数: Function; 選択範囲ごとに適用する処理の関数
* 第2引数以降: 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 ); // Brackets_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 );
  }
}
}
</source>
</source>
937行目: 1,084行目:


== 引用符を追加/削除 ==
== 引用符を追加/削除 ==
(最終更新 2020/06/03)
(最終更新 2020/06/23)


「[[#カッコで囲う (ポップアップメニューなし)|カッコで囲う (ポップアップメニューなし)]]」の機能強化版です。
「[[#カッコで囲う (ポップアップメニューなし)|カッコで囲う (ポップアップメニューなし)]]」の機能強化版です。
962行目: 1,109行目:
#title = "''引用符'' で囲う"
#title = "''引用符'' で囲う"
#tooltip = "ダブルクォーテーションで囲う"
#tooltip = "ダブルクォーテーションで囲う"
// #icon = "quote_4[2].ico"
#icon = "quote_4[2].ico"
// #icon = "Mery用 マテリアルデザインっぽいアイコン.icl",100
// #icon = "Mery用 マテリアルデザインっぽいアイコン.icl",100


968行目: 1,115行目:
  * -----------------------------------------------------------------------------
  * -----------------------------------------------------------------------------
  * "引用符" で囲う
  * "引用符" で囲う
  * sukemaru (2018/10/19 - 2020/06/03)
  * sukemaru (2018/10/19 - 2020/06/23)
  * -----------------------------------------------------------------------------
  * -----------------------------------------------------------------------------
  * (Last modified: 2020/06/03)
  * (Last modified: 2020/06/23)
* マルチカーソル/複数選択範囲に対応
* (2020/06/03)
  * 終了後フラグ  endPos = 3  での終了後のカーソル位置を調整
  * 終了後フラグ  endPos = 3  での終了後のカーソル位置を調整
  *  
  *  
985行目: 1,134行目:
var sur = '"'; // 後に付ける文字列
var sur = '"'; // 後に付ける文字列
   /**
   /**
   * ■"引用符" の文字列を指定
   * ■ "引用符" の文字列を指定
   *
   *
   * ※ 文字列をダブルクォーテーション "" で囲うなら、中の「 " 」は要エスケープ 「'"'」=> 「"\""」
   * ※ 文字列をダブルクォーテーション "" で囲うなら、中の「 " 」は要エスケープ 「'"'」=> 「"\""」
996行目: 1,145行目:
var deleteOuter = true;
var deleteOuter = true;
   /**
   /**
   *  ■外側削除フラグ
   *  ■ 外側削除フラグ
   *
   *
   * ・false で選択範囲内側の先頭/末尾の文字列 pre / sur のみを削除。
   * ・false で選択範囲内側の先頭/末尾の文字列 pre / sur のみを削除。
1,006行目: 1,155行目:
var multiLine = true;
var multiLine = true;
   /**
   /**
   * ■複数行フラグ
   * ■ 複数行フラグ
   *
   *
   * ・false で選択範囲「全体」の前後に文字列 pre / sur を追加
   * ・false で選択範囲「全体」の前後に文字列 pre / sur を追加
1,015行目: 1,164行目:
var insert = false;
var insert = false;
   /**
   /**
   * ■挿入フラグ
   * ■ 挿入フラグ
   *
   *
   * ・false では、選択範囲がないときはマクロを中止する
   * ・false では、選択範囲がないときはマクロを中止する
1,029行目: 1,178行目:
var endPos = 5; // 指定できる値は 0 ~ 5 ( 6 以上の値は 0 と同じ)
var endPos = 5; // 指定できる値は 0 ~ 5 ( 6 以上の値は 0 と同じ)
   /**
   /**
   * ■終了後フラグ
   * ■ 終了後フラグ
   *
   *
   * 0. カーソルは "引用符" の後ろへ。  (※範囲選択なし)
   * 0. カーソルは "引用符" の後ろへ。  (※範囲選択なし)
1,057行目: 1,206行目:
if ( d.ReadOnly ) {
if ( d.ReadOnly ) {
   Status = " ドキュメントは書き換え禁止です。";
   Status = " ドキュメントは書き換え禁止です。";
  // Quit();
}
}
// 挿入フラグが無効 ( insert = false ) で 選択範囲がないなら中止
// 挿入フラグが無効 ( insert = false ) で 選択範囲がないなら中止
else if ( ! insert && s.IsEmpty ) {
else if ( ! insert && s.IsEmpty ) {
   Status = " 選択範囲がありません。";
   Status = " 選択範囲がありません。";
  // Quit();
}
}


// 選択範囲がある または 挿入フラグが有効 ( s.length || insert = true ) なら ~
// 選択範囲がある または 挿入フラグが有効 ( s.length || insert = true ) なら ~
else {
else {
   Redraw = false;
   var sx = ScrollX,  sy = ScrollY;
 
  // マルチカーソル対応
  var arg = [ pre, sur, deleteOuter, multiLine, insert, endPos ];
  // 選択範囲が1つで矩形選択ではないとき
  if ( ! s.Mode || s.Mode === meModeStream ) {
    AddDeleteQuote_Main( arg );
  }
  // 複数行または複数選択のとき
  else {
    BeginUndoGroup();
    AddUndo();
    MultiFunction( AddDeleteQuote_Main, arg );
    EndUndoGroup();
  }
  ScrollX = sx;  ScrollY = sy;
}
 
 
/**
* 関数 AddDeleteQuote_Main( [ pre, sur, deleteOuter, multiLine, insert, endPos ] )
* 「引用符を追加/削除」マクロ
* サブ関数群は適切に引数を設定していないので
* Main の関数スコープ内に含める
*/
function AddDeleteQuote_Main( arg ) {
  var pre = arg[0];
  var sur = arg[1];
  var deleteOuter = arg[2];
  var multiLine  = arg[3];
  var insert      = arg[4];
  var endPos      = arg[5];


   var delCount = 0; // 削除フラグ
   var delCount = 0; // 削除フラグ
1,074行目: 1,253行目:


   // 選択範囲の各座標
   // 選択範囲の各座標
   var anc = s.GetAnchorPos();
  var d = editor.ActiveDocument,  s = d.selection;
  var act = s.GetActivePos();
   var anc = s.GetAnchorPos(),  act = s.GetActivePos();
   var tp = ( anc < act ) ? anc : act; // 選択範囲の先頭位置
   var tp = Math.min( anc, act );
   var bp = ( anc < act ) ? act : anc; // 選択範囲の末尾位置
   var bp = Math.max( anc, act );
  // var ty = s.GetTopPointY( mePosLogical );
   var bx = s.GetBottomPointX( mePosLogical );
   var bx = s.GetBottomPointX( mePosLogical );
   var by = s.GetBottomPointY( mePosLogical );
   var by = s.GetBottomPointY( mePosLogical );
1,101行目: 1,279行目:
   // AddDelBrackets() で "引用符" を追加/削除
   // AddDelBrackets() で "引用符" を追加/削除
   if ( ! delCount ) {
   if ( ! delCount ) {
     var ad = AddDelBrackets( st, pre, sur );
     var tmp = AddDelBrackets( st, pre, sur );
     if ( delCount || addCount ) {
     if ( delCount || addCount ) {
       s.Text = ad;
       s.Text = tmp;
     }
     }
     // AddDelBrackets() 処理の前後で文字列に変化がないなら
     // AddDelBrackets() 処理の前後で文字列に変化がないなら
1,110行目: 1,288行目:
       s.SetActivePos( act );
       s.SetActivePos( act );
       s.SetAnchorPos( anc );
       s.SetAnchorPos( anc );
      // Quit();
     }
     }
   }
   }
1,118行目: 1,295行目:
     var dp = s.GetActivePos();
     var dp = s.GetActivePos();
     // 終了後フラグの指定動作  ※カーソルを移動/選択範囲を復旧
     // 終了後フラグの指定動作  ※カーソルを移動/選択範囲を復旧
     FinalSelection();
     FinalSelection();
  }
 
 
  // ---------- ▼ 関数 ▼ ----------
 
  /**
  * 関数 FinalSelection()
  *  終了後フラグの指定動作  ※カーソルを移動/選択範囲を復旧
  *  0. カーソルは "引用符" の後ろへ。  (※範囲選択なし)
  *  1. カーソルは最後の "引用符" の中へ移動する。  (※範囲選択なし)
  *  2. マクロ実行前に範囲選択がなければカーソルは最後の "引用符" の中へ。  (※要 挿入フラグ = true)
  *  あれば "引用符" の後ろへ移動する。  (※範囲選択なし)
  *  3. マクロ実行前に範囲選択がなければカーソルは最後の "引用符" の中へ移動。  (※範囲選択なし)、
  *  あれば "引用符" を含めた全体を選択範囲にする。  (※カーソルは選択範囲の後ろへ)
  *  4. "引用符" を含めた全体を選択範囲にする。  (※カーソルは選択範囲の後ろへ)
  *  5. "引用符" を含めた全体を選択範囲にする。  (※カーソル位置はマクロ実行前の側(先頭 or 末尾)へ)
  */
  function FinalSelection() {
    // 0. カーソルは "引用符" のうしろ
    // ※範囲選択なし(末尾調整されたままの位置)
    switch ( endPos ) {
 
    // 1. カーソルは "引用符" の中へ移動する  ※範囲選択なし
    case 1:
      SearchCloseBracket ();
      break;
 
    // 2. マクロ実行前に範囲選択がなければカーソルは "引用符" の中へ
    //    あれば選択範囲の後ろへ移動する  ※範囲選択なし
    case 2:
      // マクロ実行前に選択範囲がなかったとき → case 1 と同じ
      if ( ! st ) {
        SearchCloseBracket();
      }
      break;
 
    // 3. マクロ実行前に範囲選択がなければカーソルは "引用符" の中へ移動  ※範囲選択なし
    //    あれば "引用符" を含めた全体を選択範囲にする  ※カーソルは選択範囲の後ろへ
    case 3:
      // マクロ実行前に選択範囲がなかったとき → case 1 と同じ
      if ( ! st ) {
        SearchCloseBracket();
      }
      // マクロ実行前に選択範囲があったとき → case 2 と同じ
      else {
        MoveToEndPos();
        s.SetAnchorPos( tp ); // 先頭まで範囲選択
      }
      break;
 
    // 4. "引用符" を含めた全体を選択範囲にする
    // ※カーソルは選択範囲の後ろへ(末尾位置を復帰)
    case 4:
      MoveToEndPos();
      s.SetAnchorPos( tp );
      break;
 
    // 5. "引用符" を含めた全体を選択範囲にする(末尾位置を復帰)
    // ※カーソル位置はマクロ実行前の側(先頭 or 末尾)へ
    case 5:
      MoveToEndPos();
      // マクロ実行前のキャレットの位置が末尾だったとき
      if ( anc == tp ) {
        s.SetAnchorPos( tp );
      }
      // マクロ実行前のキャレットの位置が先頭だったとき
      else {
        s.SetActivePos( tp, true );
      }
      break;
 
    default:
      break;
    }
   }
   }


  Redraw = true;
}


// ---------- ▼ 関数 ▼ ----------
  /* 関数 AddDelBrackets() */  
  function AddDelBrackets( str, o, c ) {
    // ■複数行フラグ ( multiLine ) にしたがい選択範囲 st を配列 a に
    var a = ( multiLine ) ? str.split( "\n" ) : [ str ];
 
    for ( var i = 0, len = a.length; i < len; i ++ ) {
      // 選択範囲がカッコで囲われているときは、各行のカッコを削除
      if ( a[i].slice( 0, o.length ) == o
      && a[i].slice( - c.length ) == c ) {
        a[i] = a[i].slice( o.length, a[i].length - c.length );
        delCount ++; // 削除フラグ
      }
      // 選択範囲がカッコで囲われていないとき
      // 挿入フラグが有効ならカッコをつける
      else if ( insert || /[^\s ]/.test( a[i] ) ) {
        a[i] = o + a[i] + c;
        addCount ++; // 追加フラグ
      }
      // 挿入フラグが無効のときの空白行はスルー
      else { continue; }
    }
 
    return a.join( "\n" );
  }
 


/**
  /* 関数 DeleteOuterBrackets() */
* 関数 FinalSelection()  
   function DeleteOuterBrackets( str, o, c ) {
*   終了後フラグの指定動作  ※カーソルを移動/選択範囲を復旧
*  0. カーソルは "引用符" の後ろへ。  (※範囲選択なし)
*   1. カーソルは最後の "引用符" の中へ移動する。  (※範囲選択なし)
*  2. マクロ実行前に範囲選択がなければカーソルは最後の "引用符" の中へ。  (※要 挿入フラグ = true)
*  あれば "引用符" の後ろへ移動する。  (※範囲選択なし)
*  3. マクロ実行前に範囲選択がなければカーソルは最後の "引用符" の中へ移動。  (※範囲選択なし)、
*  あれば "引用符" を含めた全体を選択範囲にする。  (※カーソルは選択範囲の後ろへ)
*  4. "引用符" を含めた全体を選択範囲にする。  (※カーソルは選択範囲の後ろへ)
*  5. "引用符" を含めた全体を選択範囲にする。  (※カーソル位置はマクロ実行前の側(先頭 or 末尾)へ)
*/
function FinalSelection() {
  // 0. カーソルは "引用符" のうしろ
  // ※範囲選択なし(末尾調整されたままの位置)
  switch ( endPos ) {


  // 1. カーソルは "引用符" の中へ移動する  ※範囲選択なし
    // 選択範囲外側の前後の文字列が "引用符" なら削除する
  case 1:
    if ( d.Text.slice( tp - o.length, tp ) == o
     SearchCloseBracket ();
     && d.Text.slice( bp, bp + c.length ) == c ) {
    break;
      s.SetActivePos( tp - o.length );
      s.SetAnchorPos( bp + c.length );
      s.Text = s.Text.slice( o.length, - c.length );


  // 2. マクロ実行前に範囲選択がなければカーソルは "引用符" の中へ
      tp = tp - o.length; // 先頭の座標を調整
  //   あれば選択範囲の後ろへ移動する  ※範囲選択なし
       delCount ++;
  case 2:
    // マクロ実行前に選択範囲がなかったとき → case 1 と同じ
    if ( ! st ) {
       SearchCloseBracket();
     }
     }
     break;
     return delCount; // 戻り値として削除フラグを返す
  }
 


   // 3. マクロ実行前に範囲選択がなければカーソルは "引用符" の中へ移動  ※範囲選択なし
   /* 関数 SearchCloseBracket() */  
   //   あれば "引用符" を含めた全体を選択範囲にする ※カーソルは選択範囲の後ろへ
   // カーソルを最後の閉じカッコの前へ移動 ※範囲選択なし
   case 3:
   function SearchCloseBracket() {
     // マクロ実行前に選択範囲がなかったとき → case 1 と同じ
     // カッコを削除したときは、末尾のまま
     if ( ! st ) {
     if ( delCount ) {
       SearchCloseBracket();
       s.SetActivePos( dp );
     }
     }
     // マクロ実行前に選択範囲があったとき → case 2 と同じ
     // カッコを追加したときは、選択範囲内の最後の閉じカッコの前へ
     else {
     else {
       MoveToEndPos();
       var Quote = function( str ) {
       s.SetAnchorPos( tp ); // 先頭まで範囲選択
        return str.replace( /[.*+?^=!:${}()|[\]\/\\]/g, "\\$&" );  
       };
      if ( sur.length || addCount ) {
        s.SetAnchorPos( tp );
        s.SetActivePos( tp + s.Text.lastIndexOf( s.Text.match( Quote( sur ) ) ) );
      }
      // 閉じカッコ sur が未指定 "" の場合は、末尾のまま
     }
     }
    break;
  }


  // 4. "引用符" を含めた全体を選択範囲にする
  // ※カーソルは選択範囲の後ろへ(末尾位置を復帰)
  case 4:
    MoveToEndPos();
    s.SetAnchorPos( tp );
    break;


   // 5. "引用符" を含めた全体を選択範囲にする(末尾位置を復帰)
   /* 関数 MoveToEndPos() */  
   // ※カーソル位置はマクロ実行前の側(先頭 or 末尾)へ
   // マクロ実行前に選択範囲があったとき、カーソルを元の選択範囲の末尾位置へ移動
   case 5:
   // ※範囲選択なし
    MoveToEndPos();
  function MoveToEndPos() {
     // マクロ実行前のキャレットの位置が末尾だったとき
     // 選択範囲の末尾調整をしていたときは、カーソルを元の末尾位置に復帰
     if ( anc <= act ) {
     if ( isAdjusted ) {
       s.SetAnchorPos( tp );
       s.SetActivePoint( mePosLogical, 1, by );
     }
     }
     // マクロ実行前のキャレットの位置が先頭だったとき
     // 末尾調整をしていなかったときは、カーソル位置はそのまま
     else {
     else {
       s.SetActivePos( tp, true );
       s.SetActivePos( dp );
     }
     }
     break;
  }
 
}
 
 
/**
* 関数 MultiFunction( Fn, arg1 )
* マルチカーソル(複数選択範囲)に対応させる
* 第1引数: Function; 選択範囲ごとに適用する処理の関数
* 第2引数以降: 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 ); // AddDeleteQuote_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 );
  }
}
</source>
 
 
== カッコで囲う2(各行ごとにカッコで囲う/Mery ver 3 用) ==
 
選択範囲内(複数選択可)の '''各行''' (論理行)を、ポップアップメニューから選択したアイテム(カッコ)で囲います。<br>
Mery ver 3.0.1 以降のマルチカーソル/複数選択範囲に対応 。
<br><br>
; 機能
* 複数行選択や複数選択(またはマルチカーソル状態)を行に分けたそれぞれの部分をカッコで囲います。
* 選択範囲がないときはカーソル位置(マルチカーソル可)それぞれにカッコを挿入します。
* 各選択範囲のさいごの改行は無視しますので、行番号の Ctrl+クリック による複数選択範囲でも使用できます。
<br>
; 制限事項
* <s>このマクロは Mery ver 2.x では使用できません。</s>
* 複数行の選択範囲全体を一組のカッコで囲うことはできません。
* 矩形選択範囲は複数選択範囲に分解します(選択範囲を行に分ける)。
* カッコの定義配列からポップアップメニューを自動生成する仕様のため、サブメニューを利用したカテゴリ分けはできません。
<br>
 
=== カッコの登録方法 ===
 
: ソースコード内の設定項目の配列でカッコの種類を定義します。
: カッコで挟みこまれる部分を <code>...</code> で置きかえた <code>"「...」"</code> が基本形式となります。
: 設定項目の配列にカッコの定義を追加すると、自動的にポップアップメニュー項目にも追加されるので、「カッコで囲う(ポップアップメニューあり)」マクロよりも簡単にカスタマイズできます。
<br>
: ※ <code>...</code> がないアイテムはメニューに表示されません。
: ※ <code>...</code> を行頭に付加させることはできません。
<br>
* '''各行の前後を囲う "カッコ"'''
: カッコや HTML タグ、任意の記号、文字列を <code>"「...」"</code> や <code><nowiki>"<pre>...</pre>"</nowiki></code> のように記述して登録します。
<br>
* '''各行の先頭にのみ記号や文字列を付加する場合'''
: <code>">..."</code> のように <code>...</code> の後ろに文字列をつけずに登録します。<br> 箇条書きのビュレットや行頭のコメントマーク、引用符などの挿入に利用できます。
<br>
* '''各行の末尾にのみ記号や文字列を付加する場合'''
: <code>"...!?"</code> のように <code>...</code> の前に文字列をつけずに登録します。
<br>
* ポップアップメニュー先頭の '''「任意の文字列...」コマンド''' を利用すれば、定義配列に登録していないカッコやタグ、記号など任意の文字列を指定することができます。
<br>
 
=== ソースコード ===
 
<source lang="javascript" style="height:80em; overflow:auto;">
#title = "カッコで囲う2"
#tooltip = "選択範囲の各行をカッコで囲う"
#icon = "brackets(parenthesis)[3].ico"
// #icon = "Mery用 マテリアルデザインっぽいアイコン.icl",256
 
/**
* ---------------------------------------------------------
* 「カッコで囲う2」マクロ
* sukemaru, 2020/06/05 - 2020/06/23
* rev.1 (2020/06/05): クリップボード経由 ⇒ 2020/06/23 廃止
* rev.2 (2020/06/23): 選択範囲の復帰可 / MultiFunction() 関数
* ---------------------------------------------------------
* Mery ver 3.0.1 以降のマルチカーソル(複数選択範囲)に対応
*
* 選択範囲内(複数選択可)の各行それぞれをカッコで囲います。
* ※ 選択範囲がないときはカーソル位置(マルチカーソル可)にカッコを挿入します。
* ※ 各選択範囲の末尾の改行は無視します。
*/
 
 
// ---------- ▼ 設定項目 ▼ ---------- //
 
// ■ カッコを追加した選択範囲を復帰する
var restoreSel = true; // (true する / false しない)
 
 
// ■ 「任意の文字列」で入力した文字列の一時記憶方法
var tagType = 2;
  // 0 : 一時記憶なし
  // 1 : タブ(文書)ごとに一時記憶する(Document.Tag)
  // 2 : ウインドウごとに一時記憶する(Editor.Tag)
  // 3 : すべてのタブとウインドウ共通で一時記憶する(window.Tag)
 
 
// ■ カッコ(タグ・記号等の文字列)の種類の定義
// ※ 定義ではカッコの間にドット×3 "..." をはさんでおくこと
// ※ "★..." なら前だけ、"...★" なら後ろだけに文字列をつけられる
// ※ "" でポップアップメニュー内のセパレータ(横罫線)になる
//  ( "..." を含まなければセパレータ)
 
var pp = [ "",
  "(...)", "[...]", "[[...]]", "(\"...\")", "",
  "\"...\"", " \"...\" ", "'...'", "",
  "「...」", "『...』", "【...】", "(...)", "",
  ">> ...", "> ...", "\/\/ ...", "...\t\/\/ ", "\/\* ... \*\/", "",
  "※...", "・...", "■...", "◆...◆", "",
  "''...''", "'''...'''", "<code>...</code>",
"" ];
 
// ---------- ▲ 設定項目 ▲ ---------- //
 
var tagKey = "AddBrackets2";
var separator = "...";
var spaceChar = "\u2006_\u2006"; // \u2423 ␣
 
var d = editor.ActiveDocument;
var s = d.selection;
var ac = "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var flag = d.ReadOnly ? meMenuGrayed : 0;
var p, p1, p2;
var Split = function( str, sep ) {
  sep = sep.replace( /[.*+?^=!:${}()|[\]\/\\]/g, "\\$&" );
  return RegExp( "([\\s\\S]*?)" + sep + "([\\s\\S]*)", "" ).exec( str );
}
var Conv = function( str ) {
  return str.replace( /[ ]/g, spaceChar )
            .replace( /\t/g, "\\t" )
            .replace( /\n/g, "\\n" );
};


   default:
// ポップアップメニュー
     break;
var menu = CreatePopupMenu();
menu.Add( "任意の文字列 (&@) ...", 100000, flag );
// 配列内の要素を追加
for ( var i = j = 0, len = pp.length, label; i < len; i ++ ) {
   // "..." を含まないものはセパレータ
  if ( ! pp[i] || pp[i] === separator
  || String( pp[i] ).indexOf( separator ) === -1 ) {
    menu.Add( "----", 0, meMenuSeparator );
     continue;
   }
   }
  p = Split( pp[i], separator );
  p1 = p[1];  p2 = p[2];
  label = ( ! p1 ) ? Conv( p2 ) + "  を 後ろ に付加"
        : ( ! p2 ) ? Conv( p1 ) + "  を 先頭 に挿入"
        :  Conv( p1 ) + " ・・・ " + Conv( p2 ) + "  で 前後 を囲う";
  if ( ! ac[j] ) { j = 0; }
  label += " (&" + ac[ j ++ ] + ")";
  menu.Add( label, i, flag );
}
}
menu.Add( "キャンセル & ", 0 );
if ( flag ) { Status = " ドキュメントは書き換え禁止です。"; }
var r = menu.Track( mePosMouse );
Main2:
if ( r ) {
  if ( r === 100000 ) { // 「任意の文字列」
    p = Brackets2Prompt( tagType, tagKey );
    p1 = p.p1;  p2 = p.p2;
    if ( ! p1 && ! p2 ) { break Main2; }
  }
  else {
    p = Split( pp[r], separator );
    p1 = p[1];  p2 = p[2];
  }
  var sx = ScrollX,  sy = ScrollY;


  // マルチカーソル/複数選択に対応
  var arg = [ p1, p2, restoreSel ];
  // 選択範囲が1つで矩形選択ではないとき
  if ( ! s.Mode || s.Mode === meModeStream ) {
    AddBrackets2_Main( arg );
  }
  // 矩形選択または複数選択のとき
  else {
    BeginUndoGroup();
    AddUndo();
    MultiFunction( AddBrackets2_Main, arg );
    EndUndoGroup();
  }


/* 関数 AddDelBrackets() */  
  ScrollX = sx;  ScrollY = sy;
function AddDelBrackets( str, o, c ) {
} // Main2: if ( r )


  // ■複数行フラグ ( multiLine ) にしたがい選択範囲 st を配列 a に
  var a = ( multiLine ) ? str.split( "\n" ) : [ str ];


   for ( var i = 0, len = a.length; i < len; i ++ ) {
/**
* 関数 AddBrackets2_Main( [ p1, p2, restoreSel ] )
* 選択範囲をカッコ p1, p2 で囲う
* restoreSel は実行後の選択範囲の復帰を指定する真偽値(設定項目)
*/
function AddBrackets2_Main( arg ) {
  var p1 = arg[0];
  var p2 = arg[1];
  var restoreSel = arg[2];
 
  var d = editor.ActiveDocument;
  var s = d.selection;
  var tp = Math.min( s.GetActivePos(), s.GetAnchorPos() );
   var ty = s.GetTopPointY( mePosLogical );
  var by = s.GetBottomPointY( mePosLogical );
  var bx = s.GetBottomPointX( mePosLogical );
  var nl = 0;
  if ( by > ty && bx === 1 ) {
    by --;  nl = 1;
    s.SetActivePoint( mePosLogical, d.GetLine( by, 0 ).length + 1, by );
    s.SetAnchorPos( tp );
  }
  var st = s.Text;
 
  // カッコを付加した文字列
  var tmp = st.replace( /^.*$/gm, p1 + "$&" + p2 );
 
  if ( st !== tmp ) {
    // ブックマークを保存
    var bmArray = GetBookmark( ty, by );
 
    // カッコを付加した文字列を適用
    s.Text = tmp;


     // 選択範囲がカッコで囲われているときは、各行のカッコを削除
     // ブックマークを復元
     if ( a[i].slice( 0, o.length ) == o
     RestoreBookmark( ty, by, bmArray );
    && a[i].slice( - c.length ) == c ) {
      a[i] = a[i].slice( o.length, a[i].length - c.length );
      delCount ++; // 削除フラグ
    }
    // 選択範囲がカッコで囲われていないとき
    // 挿入フラグが有効ならカッコをつける
    else if ( insert || /[^\s ]/.test( a[i] ) ) {
      a[i] = o + a[i] + c;
      addCount ++; // 追加フラグ
    }
    // 挿入フラグが無効のときの空白行はスルー
    else { continue; }
   }
   }


   return a.join( "\n" );
   s.SetActivePos( tp + tmp.length + nl );
  if ( restoreSel ) {
    s.SetAnchorPos( tp );
  }
}
}




/* 関数 DeleteOuterBrackets() */  
/**
function DeleteOuterBrackets( str, o, c ) {
* 関数 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; }
}


  // 選択範囲外側の前後の文字列が "引用符" なら削除する
/**
  if ( d.Text.slice( tp - o.length, tp ) == o
* 関数 SetTag( value, tagType, tagKey, property )
  && d.Text.slice( bp, bp + c.length ) == c ) {
* 指定された値を Tag に書き込む
    s.SetActivePos( tp - o.length );
*/
    s.SetAnchorPos( bp + c.length );
function SetTag( value, tagType, tagKey, property ) {
     s.Text = s.Text.slice( o.length, - c.length );
  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; }
}


     tp = tp - o.length; // 先頭の座標を調整
/**
    delCount ++;
* 関数 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"
          + "改行 = \\\\\\n ; タブ = \\\\\\t  (注:¥記号3つ)";
  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 delCount; // 戻り値として削除フラグを返す
   return { p1: p1, p2: p2 };
}
}




/* 関数 SearchCloseBracket() */
/**
// カーソルを最後の閉じカッコの前へ移動  ※範囲選択なし
* 関数 GetBookmark( ty, by )
function SearchCloseBracket() {
* 指定された範囲のブックマークを収集
   // カッコを削除したときは、末尾のまま
*/
   if ( delCount ) {
function GetBookmark( ty, by ) {
     s.SetActivePos( dp );
   var bmArray = [],  bmY;
  var s = editor.ActiveDocument.selection;
   if ( ty < by ) {
     var anc = s.GetAnchorPos(),  act = s.GetActivePos();
 
    if ( ty === 1 ) {
      s.SetActivePoint( mePosLogical, 1, 2 );
      if ( s.PreviousBookmark() ) {
        bmY = s.GetActivePointY( mePosLogical );
        if ( bmY >= ty && bmY <= by ) {
          bmArray.push( bmY );
        }
      }
      s.SetActivePos( 0 );
    }
    else { s.SetActivePoint( mePosLogical, 1, ty - 1 ); }
 
    while ( s.NextBookmark() ) {
      bmY = s.GetActivePointY( mePosLogical );
      if ( bmY >= ty && bmY <= by ) {
        bmArray.push( bmY );
      }
      else if ( bmY > by ) { break; }
    }
    s.SetActivePos( act );  s.SetAnchorPos( anc );
   }
   }
   // カッコを追加したときは、選択範囲内の最後の閉じカッコの前へ
   return bmArray;
  else {
}
    var Quote = function( str ) {
 
      return str.replace( /[.*+?^=!:${}()|[\]\/\\]/g, "\\$&" );  
/**
     };
* 関数 RestoreBookmark( ty, by, bmArray )
     if ( sur.length || addCount ) {
* 指定された範囲のブックマークを復元
       s.SetAnchorPos( tp );
*/
       s.SetActivePos( tp + s.Text.lastIndexOf( s.Text.match( Quote( sur ) ) ) );
function RestoreBookmark( ty, by, bmArray, sel ) {
  var bmCount = bmArray.length;
  if ( bmCount ) {
    var s = editor.ActiveDocument.selection;
    var anc = s.GetAnchorPos(),  act = s.GetActivePos();
    s.SetActivePoint( mePosLogical, 1, ty );
     s.ClearBookmark();
     for ( var i = 0; i < bmCount, bmArray[i] <= by; i ++ ) {
      if ( bmArray[i] < ty ) { continue; }
       s.SetActivePoint( mePosLogical, 1, bmArray[i], false );
       s.SetBookmark();
    }
    if ( sel ) {
      s.SetActivePos( act );  s.SetAnchorPos( anc );
     }
     }
    // 閉じカッコ sur が未指定 "" の場合は、末尾のまま
   }
   }
}
}




/* 関数 MoveToEndPos() */  
/**
// マクロ実行前に選択範囲があったとき、カーソルを元の選択範囲の末尾位置へ移動
* 関数 MultiFunction( Fn, arg1 )
// ※範囲選択なし
* マルチカーソル(複数選択範囲)に対応させる
function MoveToEndPos() {
* 第1引数: Function; 選択範囲ごとに適用する処理の関数
   // 選択範囲の末尾調整をしていたときは、カーソルを元の末尾位置に復帰
* 第2引数以降: Function に渡す引数をまとめた配列
   if ( isAdjusted ) {
*/
     s.SetActivePoint( mePosLogical, 1, by );
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 ); // AddBrackets2_Main() 関数でカッコを追加
 
    // Fn() の残した選択範囲(またはキャレット位置)を回収
    Sel[i].act = s.GetActivePos();
    Sel[i].anc = s.GetAnchorPos();
    diff += d.TextLength - dl; // 文字数の増減量(累積)
   }
   }
   // 末尾調整をしていなかったときは、カーソル位置はそのまま
 
   else {
   // マルチカーソル(複数選択範囲)を復帰
     s.SetActivePos( dp );
   for ( var i = 0; i < sCount; i ++ ) {
     s.AddPos( Sel[i].anc, Sel[i].act );
   }
   }
}
}
</source>
</source>
<br>


<!-- 記
<!-- 記
1,283行目: 1,891行目:
* 終了後の動作コードを変更し、不自然な位置にキャレットが移動する不具合を修正した (2018/10/26 sukemaru)
* 終了後の動作コードを変更し、不自然な位置にキャレットが移動する不具合を修正した (2018/10/26 sukemaru)
* 選択範囲の外側の引用符の削除に対応。終了時のカーソルの位置、範囲選択の動作を修正 (2019/03/28 sukemaru)
* 選択範囲の外側の引用符の削除に対応。終了時のカーソルの位置、範囲選択の動作を修正 (2019/03/28 sukemaru)
*「カッコで囲う2」の項目を追加 (2020/06/23 sukemaru)
  -->
  -->
<br>
<br>
1,341行目: 1,950行目:




=== マルチカーソル/複数選択範囲への対応 ===
Mery ver 3.0.1 以降のマルチカーソル(複数のキャレットを置いた状態)や複数選択範囲のそれぞれにたいして、マクロを連続的に実行します (※ ver 3.0.0 はサポート外)。
<br><br>
* 「カッコで囲う (ポップアップメニュー あり/なし)」マクロは、基本的にそれぞれの選択範囲ごとに一組のカッコで囲います。
: ※ Wiki用マークアップの各コマンドは、選択範囲内の各行ごとに囲います。
: ※ 任意の文字列/文字数系のコマンドでは、1回だけ入力ダイアログが表示され、指定した内容ですべての選択範囲を処理します。
<br>
* 「引用符を追加/削除」マクロは、設定項目 <code>multiLine</code> の true/false で指定された動作ですべての選択範囲を処理します。
: ※ "引用符" で囲った文字列と囲っていない文字列をそれぞれ範囲選択して実行すると、"引用符" で囲われた選択範囲では「削除」、囲われていない選択範囲では「追加」の動作をします。
: ※ 連続実行での「追加/削除」のトグル動作可。
<br>
* 「カッコで囲う2」マクロは、それぞれの選択範囲内の各行ごとにカッコで囲います。
<br>
* Mery ver 3.0.x ~ での矩形選択範囲にたいしては、「選択範囲を行に分け」て、選択範囲内の各行ごとに処理を実行します。
: ※ 同一論理行内の折り返しにたいしては「選択範囲を行に分ける」処理が正常になされません。
: ※ Mery ver 2.x での矩形選択範囲にたいしては、正常に処理できません。
<!--
=== GetKeyState.exe の活用 ===
=== GetKeyState.exe の活用 ===


1,387行目: 2,016行目:
}
}
</source>
</source>
 
-->


=== 更新履歴 ===
=== 更新履歴 ===


<div style="height:30em; overflow:auto;">
<div style="height:30em; overflow:auto;">
* 2020/06/23 (sukemaru)
:・「カッコで囲う2」を追加(実験カテゴリから移動・統合)
:・Mery ver 3.0.x ~ のマルチカーソル/複数選択範囲に対応
:・「カッコで囲う (ポップアップメニューあり)」のコードを整理しなおし、定義配列の変数名や、ポップアップメニューの ID などの変更あり。
* 2020/06/03 (sukemaru)
* 2020/06/03 (sukemaru)
:・「カッコで囲う (ポップアップメニューあり)」のカッコで囲まれた文字列が2つできてしまう不具合を修正。<br>  コード内の変数名などを変更(関数の戻り値を代入する変数名を <code>tmp</code> に統一)
:・「カッコで囲う (ポップアップメニューあり)」のカッコで囲まれた文字列が2つできてしまう不具合を修正。<br>  コード内の変数名などを変更(関数の戻り値を代入する変数名を <code>tmp</code> に統一)
1,460行目: 2,094行目:
----
----


◆ '''動作の不具合などがあったらお知らせ下さい。''' ◆(sukemaru)
◆ '''動作の不具合などお気づきの点があったらお知らせ下さい。''' ◆(sukemaru)


* (2020.05.22 isari)
* (2020.05.22 isari)
スポンサーリンク