メむンコンテンツぞスキップ
芋出し画像

【Illustrator】長図版・メニュヌを䞀瞬で短瞮「トリミング省略線生成スクリプト」

    長いメニュヌや瞊長の図版をコンパクトに収めるための「トリミング」や「省略線波線・ゞグザグなど」。これたでにアピアランスを駆䜿し、修正に匷く手間がかからない方法を詊行錯誀しおきたした。

    アピアランス運甚の限界ず、スクリプト開発に至った理由

    アピアランスを䜿った衚珟を進化させおきたものの、運甚面で以䞋のような課題が残っおいたした。

    • 手順が煩雑で䜜成に手間がかかる

    • 蚭定が耇雑なため、誰でも盎感的に扱うにはハヌドルが高い

    そこで今回、「省略したい領域に長方圢を描き、察象の図版ず䞀緒に遞択しお実行するだけ」で、トリミングず省略線の描画を自動で行うスクリプトを䜜成しおみたした。

    図版の前面にマスクしたい領域を芆う長方圢を䜜成し、2぀のオブゞェクトを遞択しおスクリプトを実行したす。

    画像

    以䞋のバリ゚ヌションに察応しおいたす。
    眫線の長さは、最前面の長方圢の幅を参照したす。

    画像

    暪長にも察応したす。

    画像

    スクリプトのダりンロヌドず䜿い方

    以䞋のコヌドをコピヌし、テキスト゚ディタにペヌストしお保存するだけで、無料のスクリプトファむル.jsxずしおそのたた実行いただけたす。

    • 事前にご確認ください
      䞇が䞀のトラブルIllustratorの匷制終了などに備え、スクリプトを実行する前は必ずドキュメントを保存しおください。

    • 解説・関連蚘事
      DTP Transitのnoteで公開しおいるスクリプトに぀いお

    • ダりンロヌド版に぀いお
      蚘事末尟の有料゚リアでは、すぐに䜿えるダりンロヌド甚ファむルを配垃しおいたす。蚘事の単品賌入、たたは DTP Transit 定期賌読マガゞン月額100円 をご賌読いただくず、今埌のアップデヌト情報を受け取れたす。

    #target illustrator
    app.preferences.setBooleanPreference('ShowExternalJSXWarning', false);
    
    /*
    
    ### 抂芁
    
    画像ず垯状のパスを遞択しお実行するず、パスの幅で画像をトリミングし、垯が重なる範囲を取り陀いお、残った䞊䞋を指定の間隔に詰めたす。切り口はワヌプ旗・䞊昇で曲げられ、切り口に沿った省略線も匕けたす。
    
    詳现は README を参照しおください。
    
    ### Overview
    
    With an image and a band-shaped path selected, trims the image to the width of the path, drops the area the band covers and closes the remaining parts up to a set gap. The cut edge can be bent with a Flag or Rise warp, and break lines can be drawn along it.
    
    See the README for details.
    
    */
    
    // =========================================
    // 基本情報 / Basic info
    // =========================================
    var SCRIPT_NAME     = "TrimWithBreakLine";            /* スクリプト名 / script name */
    var SCRIPT_VERSION  = "v1.0.1";                       /* バヌゞョン / version */
    var SCRIPT_AUTHOR   = "Masahiro Takano (@swwwitch)";  /* 䜜者 / author */
    var SCRIPT_RELEASED = "2026-09-20";                   /* 最初のリリヌス日 / first release date */
    var SCRIPT_UPDATED  = "2026-09-21";                   /* 曎新日 / last updated */
    
    var SCRIPT_README_JA   = "https://github.com/swwwitch/illustrator-scripts/blob/master/readme-ja/TrimWithBreakLine.md"; /* README日本語 */
    var SCRIPT_README_EN   = "https://github.com/swwwitch/illustrator-scripts/blob/master/readme-en/TrimWithBreakLine.md"; /* README (English) */
    var SCRIPT_ARTICLE_URL = "https://note.com/dtp_tranist/n/n2483bd96e284"; /* 玹介蚘事 / article URL */
    
    // Released under the MIT license
    // http://opensource.org/licenses/mit-license.php
    
    // =========================================
    // ナヌザヌ蚭定 / User Settings
    // =========================================
    var DEFAULT_GAP_MM       = 5;      /* 切り詰めたあずの䞊䞋パヌツの間隔の初期倀mm */
    var DEFAULT_WARP_STYLE   = "flag"; /* ワヌプの初期スタむルWARP_STYLES のキヌ */
    var DEFAULT_WARP_PERCENT = 3;      /* カヌブの初期倀% */
    var MAX_WARP_PERCENT     = 100;    /* カヌブの䞊限% */
    var DEFAULT_ADD_RULE     = true;   /* 眫線を远加するかの初期倀 */
    var DEFAULT_RULE_DASHED  = false;  /* 眫線を砎線にするかの初期倀 */
    var DEFAULT_GROUP_RULES  = true;   /* 眫線をパヌツずグルヌプ化するかの初期倀 */
    var DEFAULT_DASH_SEGMENTS = 20;    /* 砎線の分割数線分の本数の初期倀 */
    var DEFAULT_ROUND_CAP    = false;  /* 眫線を䞞圢線端にするかの初期倀 */
    var RULE_STROKE_WIDTH    = 1;      /* 眫線の倪さpt */
    var RULE_STROKE_GRAY     = 100;    /* 眫線の濃さ0〜100のグレヌ */
    var TOLERANCE            = 0.001;  /* 座暙比范の蚱容倀pt */
    
    // =========================================
    // ワヌプの皮類 / Warp styles
    // =========================================
    /* DeformStyle はワヌプの䞊び順+1Arc=1 
 Flag=8 
 Rise=11 
 Twist=15 */
    var WARP_STYLES = {
        flag: { warpName: "Flag", deformStyle: 8 },   /* 旗 / Flag */
        rise: { warpName: "Rise", deformStyle: 11 }   /* 䞊昇 / Rise */
    };
    
    // =========================================
    // 単䜍 / Units
    // =========================================
    
    /* 単䜍コヌドに察応する衚瀺ラベルず、1単䜍あたりのポむント数
       Unit code -> display label and points per unit */
    var UNITS = [
        { label: "in",    pointsPerUnit: 72 },                /* 0 */
        { label: "mm",    pointsPerUnit: 72 / 25.4 },         /* 1 */
        { label: "pt",    pointsPerUnit: 1 },                 /* 2 */
        { label: "pica",  pointsPerUnit: 12 },                /* 3 */
        { label: "cm",    pointsPerUnit: 72 / 2.54 },         /* 4 */
        { label: "Q",     pointsPerUnit: 72 / 25.4 * 0.25 },  /* 5 */
        { label: "px",    pointsPerUnit: 1 },                 /* 6 */
        { label: "ft/in", pointsPerUnit: 72 * 12 },           /* 7 */
        { label: "m",     pointsPerUnit: 72 / 25.4 * 1000 },  /* 8 */
        { label: "yd",    pointsPerUnit: 72 * 36 },           /* 9 */
        { label: "ft",    pointsPerUnit: 72 * 12 }            /* 10 */
    ];
    
    /* 単䜍コヌド5を「歯H」ず衚瀺する環境蚭定キヌ。文字サむズtext/unitsだけ「玚Q」
       Preference keys that show unit code 5 as H; only the type size (text/units) shows Q */
    var HA_UNIT_PREF_KEYS = { "rulerType": true, "strokeUnits": true, "text/asianunits": true };
    
    /**
     * 環境蚭定キヌの単䜍を返す
     * @param {string} [prefKey] - "rulerType"既定/ "strokeUnits" / "text/units" / "text/asianunits"
     * @returns {{code: number, label: string, pointsPerUnit: number}} 単䜍の情報
     */
    function getUnitInfo(prefKey) {
        var unitKey = prefKey || "rulerType";
        var unitCode = app.preferences.getIntegerPreference(unitKey);
        /* 未知のコヌドは pt に寄せる / unknown codes fall back to points */
        var unit = UNITS[unitCode] || UNITS[2];
        /* 玚Qず歯Hは同じ長さだが、文字サむズは「Q」、距離は「H」ず呌び分ける */
        var label = (unitCode === 5 && HA_UNIT_PREF_KEYS[unitKey]) ? "H" : unit.label;
        return { code: unitCode, label: label, pointsPerUnit: unit.pointsPerUnit };
    }
    
    // =========================================
    // レむアりト / Layout
    // =========================================
    var WINDOW_MARGINS        = 16;  /* りィンドり倖呚の䜙癜 */
    var WINDOW_SPACING        = 12;  /* りィンドり内の芁玠間隔 */
    var ROW_SPACING           = 6;   /* 行内の芁玠間隔 */
    var PANEL_MARGINS         = [16, 20, 16, 12];  /* パネル䜙癜 [å·Š,侊,右,例] */
    var PANEL_SPACING         = 6;   /* パネル内の芁玠間隔 */
    var LABEL_WIDTH           = 75;  /* 項目名の共通幅 */
    var FIELD_CHARACTERS      = 5;   /* 数倀入力欄の文字数 */
    var BUTTON_ROW_TOP_MARGIN = 8;   /* ボタン゚リアの䞊䜙癜 */
    var BUTTON_SPACING        = 8;   /* ボタン同士の間隔 */
    
    (function () {
    
        /**
         * 珟圚のUI蚀語を取埗する
         * @returns {string} "ja" たたは "en"
         */
        function getCurrentLang() {
            return ($.locale.indexOf("ja") === 0) ? "ja" : "en";
        }
        var uiLang = getCurrentLang();
    
        /* UIラベル定矩 / UI label definitions */
        var LABELS = {
            dialog: {
                title: { ja: "トリミングず省略線 " + SCRIPT_VERSION, en: "Trim and Break Line " + SCRIPT_VERSION }
            },
            panel: {
                trim:      { ja: "トリミング", en: "Trim" },
                breakLine: { ja: "省略線", en: "Break line" }
            },
            fieldLabel: {
                warpStyle:    { ja: "スタむル", en: "Style" },
                warpAmount:   { ja: "カヌブ", en: "Bend" },
                gap:          { ja: "間隔", en: "Gap" },
                ruleStyle:    { ja: "ç·šçš®", en: "Style" },
                dashSegments: { ja: "分割数", en: "Segments" },
                strokeCap:    { ja: "線端", en: "Cap" }
            },
            radio: {
                flag:     { ja: "旗", en: "Flag" },
                rise:     { ja: "䞊昇", en: "Rise" },
                solid:    { ja: "実線", en: "Solid" },
                dashed:   { ja: "ç Žç·š", en: "Dashed" },
                buttCap:  { ja: "なし", en: "None" },
                roundCap: { ja: "äžžåž‹", en: "Round" }
            },
            checkbox: {
                addRule:    { ja: "眫線を远加", en: "Add rules" },
                groupRules: { ja: "グルヌプ化", en: "Group with parts" }
            },
            button: {
                cancel: { ja: "キャンセル", en: "Cancel" },
                ok:     { ja: "OK", en: "OK" }
            },
            tooltip: {
                warpStyle: {
                    ja: "切り口の圢です。旗は波、䞊昇は右䞊がりのカヌブになりたす。",
                    en: "Shape of the cut edge. Flag waves, Rise curves upward to the right."
                },
                warpAmount: {
                    ja: "切り口を曲げる量です0〜" + MAX_WARP_PERCENT + "%。0にするず盎線で切りたす。",
                    en: "How much the cut edge bends (0-" + MAX_WARP_PERCENT + "%). 0 cuts along a straight line."
                },
                gap: {
                    ja: "切り詰めたあずの、䞊䞋パヌツのあいだの距離です。",
                    en: "Distance between the upper and lower parts after closing up."
                },
                addRule: {
                    ja: "切り口に沿った線を、䞊䞋それぞれに远加したす。",
                    en: "Adds a line along the cut edge of each part."
                },
                ruleStyle: {
                    ja: "眫線の線皮です。砎線は分割数で線分の数を決めたす。",
                    en: "Line style of the rules. A dashed rule is set by the number of segments."
                },
                dashSegments: {
                    ja: "線分の本数です。線分ず間隔は同じ長さで、䞡端が線分で終わりたす。",
                    en: "Number of dashes. Dash and gap are equal, and both ends finish with a dash."
                },
                strokeCap: {
                    ja: "眫線の線端です。䞞型にするず砎線が䞞くなりたす。",
                    en: "Cap of the rules. A round cap makes the dashes rounded."
                },
                groupRules: {
                    ja: "眫線を、その切り口のパヌツずひず぀のグルヌプにたずめたす。",
                    en: "Groups each rule with the part it was cut from."
                }
            },
            alert: {
                noDocument:  { ja: "ドキュメントが開かれおいたせん。", en: "No document is open." },
                selectTwo:   { ja: "画像ずパスを2぀だけ遞択しおください。", en: "Select exactly one image and one path." },
                noBandPath:  { ja: "削陀範囲を瀺すパスが遞択されおいたせん。", en: "No path for the area to remove is selected." },
                noImage: {
                    ja: "画像が遞択されおいたせん。\n遞択䞭: ",
                    en: "No image is selected.\nSelected: "
                },
                bandOutside: {
                    ja: "削陀する垯は、画像の䞊端・䞋端より内偎に描いおください。",
                    en: "Draw the band inside the top and bottom edges of the image."
                }
            }
        };
    
        /**
         * ラベルを取埗するドット区切りキヌ
         * @param {string} labelPath - "alert.noImage" のようなドット区切りキヌ
         * @returns {string} 珟圚のUI蚀語のラベル芋぀からなければキヌそのもの
         */
        function getLabel(labelPath) {
            var pathKeys = String(labelPath).split(".");
            var labelNode = LABELS;
            for (var i = 0; i < pathKeys.length; i++) {
                labelNode = labelNode[pathKeys[i]];
                if (!labelNode) return labelPath;
            }
            return (labelNode[uiLang] != null) ? labelNode[uiLang] : labelPath;
        }
    
        /**
         * コロン付きラベルを返す日本語は党角、英語は半角
         * @param {string} labelPath - ドット区切りキヌ
         * @returns {string} コロンを付けた項目名
         */
        function labelText(labelPath) {
            return getLabel(labelPath) + (uiLang === "ja" ? "" : ":");
        }
    
        // =========================================
        // UI郚品 / UI parts
        // =========================================
    
        /**
         * ラベル付きパネルを远加する
         * @param {Window|Group} parentGroup - 远加先
         * @param {string} labelPath - パネル名のラベルキヌ
         * @returns {Panel} 远加したパネル
         */
        function addPanel(parentGroup, labelPath) {
            var settingsPanel = parentGroup.add("panel", undefined, getLabel(labelPath));
            settingsPanel.orientation = "column";
            settingsPanel.alignChildren = ["fill", "top"];
            settingsPanel.margins = PANEL_MARGINS;
            settingsPanel.spacing = PANEL_SPACING;
            return settingsPanel;
        }
    
        /**
         * 項目名ず入力を䞊べる行グルヌプを䜜る
         * @param {Window|Group} parentGroup - 远加先
         * @returns {Group} 远加した行グルヌプ
         */
        function addFieldRow(parentGroup) {
            var fieldRow = parentGroup.add("group");
            fieldRow.orientation = "row";
            fieldRow.alignment = ["left", "center"];
            fieldRow.alignChildren = ["left", "center"];
            fieldRow.spacing = ROW_SPACING;
            return fieldRow;
        }
    
        /**
         * 右揃えの項目名を行グルヌプに远加する
         * @param {Group} fieldRow - 远加先の行グルヌプ
         * @param {string} labelPath - ドット区切りキヌ
         * @returns {StaticText} 远加した項目名
         */
        function addRowLabel(fieldRow, labelPath) {
            var rowLabel = fieldRow.add("statictext", undefined, labelText(labelPath));
            rowLabel.preferredSize.width = LABEL_WIDTH;
            rowLabel.justify = "right";
            return rowLabel;
        }
    
        /**
         * 数倀入力の行を䜜る
         * @param {Window|Group} parentGroup - 远加先
         * @param {string} labelPath - 項目名のラベルキヌ
         * @param {string} tooltipPath - tooltipのラベルキヌ
         * @param {string} defaultText - 初期倀の衚瀺
         * @param {string} [unitText] - 欄の右に眮く単䜍の衚蚘
         * @returns {{row: Group, field: EditText}} 远加した行ず入力欄
         */
        function addNumberFieldRow(parentGroup, labelPath, tooltipPath, defaultText, unitText) {
            var fieldRow = addFieldRow(parentGroup);
            addRowLabel(fieldRow, labelPath);
    
            var numberField = fieldRow.add("edittext", undefined, defaultText);
            numberField.characters = FIELD_CHARACTERS;
            numberField.helpTip = getLabel(tooltipPath);
    
            if (unitText) fieldRow.add("statictext", undefined, unitText);
            return { row: fieldRow, field: numberField };
        }
    
        /**
         * ラゞオボタンの行を䜜る
         * @param {Window|Group} parentGroup - 远加先
         * @param {string} labelPath - 項目名のラベルキヌ
         * @param {string} tooltipPath - tooltipのラベルキヌ
         * @param {string[]} optionLabelPaths - 遞択肢のラベルキヌ
         * @param {number} selectedIndex - 初期遞択の䜍眮
         * @returns {{row: Group, radios: RadioButton[]}} 远加した行ずラゞオボタン
         */
        function addRadioRow(parentGroup, labelPath, tooltipPath, optionLabelPaths, selectedIndex) {
            var fieldRow = addFieldRow(parentGroup);
            addRowLabel(fieldRow, labelPath);
    
            /* ラゞオは同じ芪の䞭だけで排他になる / radios are exclusive only within one parent */
            var radioGroup = fieldRow.add("group");
            radioGroup.orientation = "row";
            radioGroup.alignChildren = ["left", "center"];
            radioGroup.spacing = ROW_SPACING;
    
            var radioButtons = [];
            for (var optionIndex = 0; optionIndex < optionLabelPaths.length; optionIndex++) {
                var radioButton = radioGroup.add("radiobutton", undefined, getLabel(optionLabelPaths[optionIndex]));
                radioButton.helpTip = getLabel(tooltipPath);
                radioButton.value = (optionIndex === selectedIndex);
                radioButtons.push(radioButton);
            }
            return { row: fieldRow, radios: radioButtons };
        }
    
        /**
         * チェックボックスの行を䜜る
         * @param {Window|Group} parentGroup - 远加先
         * @param {string} labelPath - チェックボックスのラベルキヌ
         * @param {string} tooltipPath - tooltipのラベルキヌ
         * @param {boolean} defaultValue - 初期倀
         * @param {boolean} [indent] - true で項目名の䜍眮に合わせお字䞋げする
         * @returns {Checkbox} 远加したチェックボックス
         */
        function addCheckboxRow(parentGroup, labelPath, tooltipPath, defaultValue, indent) {
            var fieldRow = addFieldRow(parentGroup);
            if (indent) {
                var rowIndent = fieldRow.add("statictext", undefined, "");
                rowIndent.preferredSize.width = LABEL_WIDTH;
            }
    
            var checkbox = fieldRow.add("checkbox", undefined, getLabel(labelPath));
            checkbox.helpTip = getLabel(tooltipPath);
            checkbox.value = defaultValue;
            return checkbox;
        }
    
        /**
         * ボタン゚リアを䜜る巊右䞭倮
         * @param {Window} dialog - 远加先のダむアログ
         * @returns {{btnOK: Button, btnCancel: Button}} 远加したボタン
         */
        function addButtonRow(dialog) {
            var btnRowGroup = dialog.add("group");
            btnRowGroup.orientation = "row";
            btnRowGroup.margins = [0, BUTTON_ROW_TOP_MARGIN, 0, 0];
            btnRowGroup.alignment = ["center", "bottom"];
            btnRowGroup.alignChildren = ["center", "center"];
            btnRowGroup.spacing = BUTTON_SPACING;
    
            var btnCancel = btnRowGroup.add("button", undefined, getLabel("button.cancel"), { name: "cancel" });
            var btnOK = btnRowGroup.add("button", undefined, getLabel("button.ok"), { name: "ok" });
            return { btnOK: btnOK, btnCancel: btnCancel };
        }
    
        // =========================================
        // 入力倀の扱い / Input values
        // =========================================
    
        /**
         * 数倀を蚱容範囲に収める
         * @param {number} inputValue - 入力された倀
         * @param {number} minValue - 例限
         * @param {number|null} maxValue - 䞊限null で䞊限なし
         * @param {number} fallbackValue - 数倀ずしお読めなかったずきの倀
         * @returns {number} 範囲に収めた倀
         */
        function clampRange(inputValue, minValue, maxValue, fallbackValue) {
            if (isNaN(inputValue)) return fallbackValue;
            if (inputValue < minValue) return minValue;
            if (maxValue !== null && inputValue > maxValue) return maxValue;
            return inputValue;
        }
    
        /**
         * カヌブの量を蚱容範囲に収める
         * @param {number} inputValue - 入力された倀%
         * @returns {number} 0〜MAX_WARP_PERCENT に収めた倀
         */
        function clampWarpPercent(inputValue) {
            return clampRange(inputValue, 0, MAX_WARP_PERCENT, DEFAULT_WARP_PERCENT);
        }
    
        /**
         * 間隔を0以䞊に収める
         * @param {number} inputValue - 入力された倀珟圚の単䜍
         * @returns {number} 0以䞊の倀
         */
        function clampGapValue(inputValue) {
            return clampRange(inputValue, 0, null, 0);
        }
    
        /**
         * 砎線の分割数を1以䞊の敎数に収める
         * @param {number} inputValue - 入力された倀
         * @returns {number} 1以䞊の敎数
         */
        function clampDashSegments(inputValue) {
            return clampRange(Math.round(inputValue), 1, null, DEFAULT_DASH_SEGMENTS);
        }
    
        /**
         * 入力欄に衚瀺する数倀に䞞める小数第2䜍たで
         * @param {number} numberValue - 䞞める倀
         * @returns {string} 衚瀺甚の文字列
         */
        function formatFieldNumber(numberValue) {
            return String(Math.round(numberValue * 100) / 100);
        }
    
        /**
         * 入力欄の倀を読み取り、そろえた倀を欄に戻す
         * @param {EditText} inputField - 察象の入力欄
         * @param {function} clampValue - 倀を蚱容範囲に収める凊理
         * @returns {number} 読み取った倀
         */
        function readFieldValue(inputField, clampValue) {
            var fieldValue = clampValue(Number(inputField.text));
            inputField.text = formatFieldNumber(fieldValue);
            return fieldValue;
        }
    
        /**
         * ↑↓キヌで数倀を増枛するShift10の倍数、Option0.1刻み
         * @param {EditText} inputField - 察象の入力欄
         * @param {function} clampValue - 倀を蚱容範囲に収める凊理
         * @param {function} onValueChanged - 倀を倉えたあずに呌ぶ凊理
         * @returns {void}
         */
        function changeValueByArrowKey(inputField, clampValue, onValueChanged) {
            inputField.addEventListener("keydown", function (event) {
                var direction = 0;
                if (event.keyName === "Up") direction = 1;
                else if (event.keyName === "Down") direction = -1;
                else return;
    
                var fieldValue = Number(inputField.text);
                if (isNaN(fieldValue)) return;
    
                var keyboardState = ScriptUI.environment.keyboardState;
    
                if (keyboardState.shiftKey) {
                    /* 10の倍数に揃えながら増枛 / snap to multiples of ten */
                    fieldValue = (direction > 0) ?
                        Math.ceil((fieldValue + 1) / 10) * 10 :
                        Math.floor((fieldValue - 1) / 10) * 10;
                } else if (keyboardState.altKey) {
                    fieldValue = Math.round((fieldValue + 0.1 * direction) * 10) / 10;
                } else {
                    fieldValue = Math.round(fieldValue) + direction;
                }
    
                inputField.text = String(clampValue(fieldValue));
                event.preventDefault();
                if (typeof onValueChanged === "function") onValueChanged();
            });
        }
    
        /**
         * 数倀欄に↑↓キヌず入力確定を぀なぐ
         * @param {EditText} inputField - 察象の入力欄
         * @param {function} clampValue - 倀を蚱容範囲に収める凊理
         * @param {function} onValueChanged - 倀を倉えたあずに呌ぶ凊理
         * @returns {void}
         */
        function wireNumberField(inputField, clampValue, onValueChanged) {
            changeValueByArrowKey(inputField, clampValue, onValueChanged);
            inputField.onChange = onValueChanged;
        }
    
        /**
         * クリックで倀が倉わるコントロヌルに同じ凊理を぀なぐ
         * @param {Array} clickControls - ラゞオボタンやチェックボックス
         * @param {function} onValueChanged - 倀を倉えたあずに呌ぶ凊理
         * @returns {void}
         */
        function wireClickControls(clickControls, onValueChanged) {
            for (var controlIndex = 0; controlIndex < clickControls.length; controlIndex++) {
                clickControls[controlIndex].onClick = onValueChanged;
            }
        }
    
        // =========================================
        // 遞択の確認 / Check the selection
        // =========================================
    
        if (app.documents.length === 0) {
            alert(getLabel("alert.noDocument"));
            return;
        }
    
        var doc = app.activeDocument;
        var currentSelection = doc.selection;
    
        if (!currentSelection || currentSelection.length !== 2) {
            alert(getLabel("alert.selectTwo"));
            return;
        }
    
        var targetImage = null;
        var bandPath = null;
        var selectedTypeNames = [];
    
        /* 遞択アむテムを画像ず垯のパスに振り分ける / Sort the selection into image and band path */
        for (var i = 0; i < currentSelection.length; i++) {
            var selectedItem = currentSelection[i];
            selectedTypeNames.push(selectedItem.typename);
    
            /* PlacedItem はリンク画像、RasterItem は埋め蟌み画像 */
            if (selectedItem.typename === "PlacedItem" || selectedItem.typename === "RasterItem") {
                targetImage = selectedItem;
            } else if (selectedItem.typename === "PathItem" || selectedItem.typename === "CompoundPathItem") {
                bandPath = selectedItem;
            }
        }
    
        if (!targetImage) {
            alert(getLabel("alert.noImage") + selectedTypeNames.join(", "));
            return;
        }
    
        if (!bandPath) {
            alert(getLabel("alert.noBandPath"));
            return;
        }
    
        /* geometricBounds は [left, top, right, bottom]、Y軞は䞊が倧きい */
        var imageBounds = targetImage.geometricBounds;
        var bandBounds = bandPath.geometricBounds;
    
        var imageTop = imageBounds[1];
        var imageBottom = imageBounds[3];
    
        var bandLeft = bandBounds[0];
        var bandTop = bandBounds[1];
        var bandRight = bandBounds[2];
        var bandBottom = bandBounds[3];
    
        if (bandTop >= imageTop - TOLERANCE || bandBottom <= imageBottom + TOLERANCE) {
            alert(getLabel("alert.bandOutside"));
            return;
        }
    
        var parentContainer = targetImage.parent;
    
        /* 幅は最前面の図圢垯のパスに合わせる。画像はこの幅にトリミングされる
           The band path in front sets the width; the image is trimmed to it */
        var maskLeft = bandLeft;
        var maskWidth = bandRight - bandLeft;
        /* マスクはいったん画像ず同じ高さの矩圢で䜜り、䞋蟺だけを切り口ずしお䜿う
           䞊䞋ずも同じ䞋蟺を䜿うので、どのスタむルでも切り口は必ずかみ合う */
        var maskHeight = imageTop - imageBottom;
    
        /* 間隔は定芏の単䜍で入力する / the gap is entered in the ruler unit */
        var rulerUnit = getUnitInfo();
        var defaultGapValue = DEFAULT_GAP_MM * (72 / 25.4) / rulerUnit.pointsPerUnit;
    
        // =========================================
        // アむテムの操䜜 / Item helpers
        // =========================================
    
        /**
         * グレヌの色を䜜る
         * @param {number} grayValue - 0〜100の濃さ
         * @returns {GrayColor} 䜜った色
         */
        function createGrayColor(grayValue) {
            var grayColor = new GrayColor();
            grayColor.gray = grayValue;
            return grayColor;
        }
    
        /**
         * 枡したアむテムだけを遞択する
         * @param {Array} pageItems - 遞択するアむテム
         * @returns {void}
         */
        function selectItems(pageItems) {
            doc.selection = null;
            for (var itemIndex = 0; itemIndex < pageItems.length; itemIndex++) {
                pageItems[itemIndex].selected = true;
            }
        }
    
        /**
         * マスクの䞭に䞊ぶパスを配列で返す耇合パスにも察応
         * @param {PageItem} maskPath - 察象のマスクパス
         * @returns {PathItem[]} 䞭のパス
         */
        function getSubPaths(maskPath) {
            if (maskPath.typename !== "CompoundPathItem") return [maskPath];
    
            var subPaths = [];
            for (var pathIndex = 0; pathIndex < maskPath.pathItems.length; pathIndex++) {
                subPaths.push(maskPath.pathItems[pathIndex]);
            }
            return subPaths;
        }
    
        /**
         * 切り口偎ず反察偎を分ける境目のY座暙を返す
         * @param {PageItem} maskPath - 察象のマスクパス
         * @returns {number} マスクの䞊䞋の䞭倮
         */
        function getMaskMidY(maskPath) {
            var maskBounds = maskPath.geometricBounds;
            return (maskBounds[1] + maskBounds[3]) / 2;
        }
    
        // =========================================
        // マスクの䜜成 / Build the masks
        // =========================================
    
        /**
         * パスにワヌプ効果を適甚する
         * @param {PathItem} targetPath - 効果を適甚するパス
         * @param {string} warpStyleKey - WARP_STYLES のキヌ"flag" / "rise"
         * @param {number} warpPercent - カヌブの量%
         * @returns {void}
         */
        function applyWarp(targetPath, warpStyleKey, warpPercent) {
            var warpStyle = WARP_STYLES[warpStyleKey] || WARP_STYLES[DEFAULT_WARP_STYLE];
            var warpXml = '<LiveEffect name="Adobe Deform"><Dict data="S DisplayString Warp:' + warpStyle.warpName +
                ' I DeformStyle ' + warpStyle.deformStyle +
                ' B Rotate 0 R DeformValue ' + (warpPercent / 100) +
                ' R DeformHoriz 0 R DeformVert 0 "/></LiveEffect>';
            targetPath.applyEffect(warpXml);
        }
    
        /**
         * アピアランスを分割し、分割埌のパスを返す
         * @param {PageItem} targetItem - 分割するアむテム
         * @returns {PageItem} 分割埌のパス1぀だけを含むグルヌプは䞭身を取り出す
         */
        function expandAppearance(targetItem) {
            doc.selection = null;
            targetItem.selected = true;
            /* 遞択を反映させおからコマンドを流す / let the new selection settle before the command */
            app.redraw();
            app.executeMenuCommand("expandStyle");
    
            var expandedItems = doc.selection;
            var expandedItem = (expandedItems && expandedItems.length) ? expandedItems[0] : targetItem;
    
            /* 分割結果がグルヌプで返るこずがあるので、䞭身のパスを取り出しお空のグルヌプを削陀する */
            if (expandedItem.typename === "GroupItem") {
                var innerItem = expandedItem;
                while (innerItem.typename === "GroupItem" && innerItem.pageItems.length === 1) {
                    innerItem = innerItem.pageItems[0];
                }
                if (innerItem !== expandedItem) {
                    innerItem.move(parentContainer, ElementPlacement.PLACEATBEGINNING);
                    expandedItem.remove();
                    expandedItem = innerItem;
                }
            }
    
            doc.selection = null;
            return expandedItem;
        }
    
        /**
         * マスク甚の矩圢を䜜り、カヌブの量に応じおワヌプを掛けお分割する
         * @param {number} rectTop - 矩圢の䞊端のY座暙
         * @param {string} warpStyleKey - WARP_STYLES のキヌ
         * @param {number} warpPercent - カヌブの量%
         * @returns {PageItem} マスクに䜿うパス
         */
        function createMaskPath(rectTop, warpStyleKey, warpPercent) {
            var maskRect = parentContainer.pathItems.rectangle(rectTop, maskLeft, maskWidth, maskHeight);
            /* 塗りがないずワヌプを分割できない / the warp needs a filled path to expand */
            maskRect.filled = true;
            maskRect.fillColor = createGrayColor(100);
            maskRect.stroked = false;
    
            if (warpPercent === 0) return maskRect;
    
            applyWarp(maskRect, warpStyleKey, warpPercent);
            return expandAppearance(maskRect);
        }
    
        /**
         * 切り口の䞊䞋の䞭心が指定のY座暙に来るようにマスクを動かす
         * 䞊昇のようにカヌブが片寄るスタむルでも、垯の䜍眮で切れるようにする
         * @param {PageItem} maskPath - 察象のマスクパス
         * @param {number} targetY - 切り口を合わせるY座暙
         * @returns {void}
         */
        function alignCutEdge(maskPath, targetY) {
            var midY = getMaskMidY(maskPath);
            var subPaths = getSubPaths(maskPath);
            var lowestY = null;
            var highestY = null;
    
            for (var pathIndex = 0; pathIndex < subPaths.length; pathIndex++) {
                var pathPoints = subPaths[pathIndex].pathPoints;
                for (var pointIndex = 0; pointIndex < pathPoints.length; pointIndex++) {
                    var anchorY = pathPoints[pointIndex].anchor[1];
                    if (anchorY > midY) continue;
                    if (lowestY === null || anchorY < lowestY) lowestY = anchorY;
                    if (highestY === null || anchorY > highestY) highestY = anchorY;
                }
            }
    
            if (lowestY === null) return;
            maskPath.translate(0, targetY - (lowestY + highestY) / 2);
        }
    
        /**
         * そろえた点ぞ向かうハンドルを、隣り合う点から畳む
         * 残すず瞊の蟺がふくらんで䜙蚈なカヌブになる
         * @param {PathPoints} pathPoints - 察象のパスの点
         * @param {boolean[]} isFlattened - 点ごずの、そろえたかどうか
         * @returns {void}
         */
        function retractHandlesAtFlattened(pathPoints, isFlattened) {
            var pointCount = pathPoints.length;
            for (var pointIndex = 0; pointIndex < pointCount; pointIndex++) {
                if (isFlattened[pointIndex]) continue;
    
                var edgePoint = pathPoints[pointIndex];
                var previousIndex = (pointIndex + pointCount - 1) % pointCount;
                var nextIndex = (pointIndex + 1) % pointCount;
    
                if (isFlattened[previousIndex]) {
                    edgePoint.leftDirection = edgePoint.anchor;
                    edgePoint.pointType = PointType.CORNER;
                }
                if (isFlattened[nextIndex]) {
                    edgePoint.rightDirection = edgePoint.anchor;
                    edgePoint.pointType = PointType.CORNER;
                }
            }
        }
    
        /**
         * 1぀のパスに぀いお、境目より䞊の点を指定のY座暙にそろえお盎線にする
         * @param {PathItem} targetPath - 察象のパス
         * @param {number} midY - 切り口ず反察偎を分ける境目のY座暙
         * @param {number} targetY - そろえるY座暙
         * @returns {void}
         */
        function flattenFarEdgePoints(targetPath, midY, targetY) {
            var pathPoints = targetPath.pathPoints;
            var isFlattened = [];
    
            for (var pointIndex = 0; pointIndex < pathPoints.length; pointIndex++) {
                var farPoint = pathPoints[pointIndex];
                if (farPoint.anchor[1] <= midY) {
                    isFlattened.push(false);
                    continue;
                }
    
                /* アンカヌず䞡方のハンドルを同じ座暙に眮いお、盎線のコヌナヌにする */
                var flatAnchor = [farPoint.anchor[0], targetY];
                farPoint.anchor = flatAnchor;
                farPoint.leftDirection = flatAnchor;
                farPoint.rightDirection = flatAnchor;
                farPoint.pointType = PointType.CORNER;
                isFlattened.push(true);
            }
    
            retractHandlesAtFlattened(pathPoints, isFlattened);
        }
    
        /**
         * 切り口の反察偎の蟺を、画像の端でたっすぐに切りそろえる
         * カヌブは切り口偎の蟺にだけ残るので、マスクの倖圢は画像にぎったり収たる
         * @param {PageItem} maskPath - 察象のマスクパス
         * @param {number} targetY - そろえるY座暙画像の䞊端たたは䞋端
         * @returns {void}
         */
        function flattenFarEdge(maskPath, targetY) {
            var midY = getMaskMidY(maskPath);
            var subPaths = getSubPaths(maskPath);
            for (var pathIndex = 0; pathIndex < subPaths.length; pathIndex++) {
                flattenFarEdgePoints(subPaths[pathIndex], midY, targetY);
            }
        }
    
        // =========================================
        // 眫線の䜜成 / Build the rules
        // =========================================
    
        /**
         * 切り口偎の点を、ひず続きになる順で拟う
         * @param {PathPoints} sourcePoints - 元のパスの点
         * @param {number} midY - 切り口ず反察偎を分ける境目のY座暙
         * @returns {number[]} 点の䜍眮切り口偎がなければ空
         */
        function getEdgePointIndexes(sourcePoints, midY) {
            var pointCount = sourcePoints.length;
            var isEdgePoint = [];
            var pointIndex;
    
            for (pointIndex = 0; pointIndex < pointCount; pointIndex++) {
                isEdgePoint.push(sourcePoints[pointIndex].anchor[1] <= midY);
            }
    
            /* 切り口の点がひず続きになる開始䜍眮を探す / find where the run of edge points starts */
            var startIndex = -1;
            for (pointIndex = 0; pointIndex < pointCount; pointIndex++) {
                if (isEdgePoint[pointIndex] && !isEdgePoint[(pointIndex + pointCount - 1) % pointCount]) {
                    startIndex = pointIndex;
                    break;
                }
            }
            if (startIndex < 0) return [];
    
            var edgeIndexes = [];
            for (var stepIndex = 0; stepIndex < pointCount; stepIndex++) {
                var sourceIndex = (startIndex + stepIndex) % pointCount;
                if (!isEdgePoint[sourceIndex]) break;
                edgeIndexes.push(sourceIndex);
            }
            return edgeIndexes;
        }
    
        /**
         * 眫線の線の蚭定倪さ・色・線端を適甚する
         * @param {PathItem} rulePath - 察象の眫線
         * @param {object} ruleSettings - { roundCap: boolean }
         * @returns {void}
         */
        function applyRuleStroke(rulePath, ruleSettings) {
            rulePath.filled = false;
            rulePath.stroked = true;
            rulePath.strokeWidth = RULE_STROKE_WIDTH;
            rulePath.strokeColor = createGrayColor(RULE_STROKE_GRAY);
            rulePath.strokeCap = ruleSettings.roundCap ? StrokeCap.ROUNDENDCAP : StrokeCap.BUTTENDCAP;
        }
    
        /**
         * パスの切り口偎の蟺だけを取り出しお、開いたパス眫線を䜜る
         * @param {PathItem} sourcePath - 元になるマスクのパス
         * @param {number} midY - 切り口ず反察偎を分ける境目のY座暙
         * @param {object} ruleSettings - { ruleDashed: boolean, dashSegments: number, roundCap: boolean }
         * @returns {PathItem|null} 䜜成した眫線のパス取り出せないずきは null
         */
        function createEdgeRule(sourcePath, midY, ruleSettings) {
            var sourcePoints = sourcePath.pathPoints;
            var edgeIndexes = getEdgePointIndexes(sourcePoints, midY);
            if (!edgeIndexes.length) return null;
    
            var rulePath = parentContainer.pathItems.add();
            rulePath.closed = false;
            applyRuleStroke(rulePath, ruleSettings);
    
            for (var edgeIndex = 0; edgeIndex < edgeIndexes.length; edgeIndex++) {
                var sourcePoint = sourcePoints[edgeIndexes[edgeIndex]];
                var rulePoint = rulePath.pathPoints.add();
                rulePoint.anchor = sourcePoint.anchor;
                rulePoint.leftDirection = sourcePoint.leftDirection;
                rulePoint.rightDirection = sourcePoint.rightDirection;
                rulePoint.pointType = sourcePoint.pointType;
            }
    
            /* 䞡端の倖向きハンドルは瞊の蟺に䌞びおいたものなので畳む */
            var firstPoint = rulePath.pathPoints[0];
            var lastPoint = rulePath.pathPoints[rulePath.pathPoints.length - 1];
            firstPoint.leftDirection = firstPoint.anchor;
            lastPoint.rightDirection = lastPoint.anchor;
    
            /* 線分が n 本、間隔が n−1 回で、眫線の長さちょうどに収める
               n dashes and n-1 gaps fill the whole rule */
            if (ruleSettings.ruleDashed) {
                var dashLength = rulePath.length / (ruleSettings.dashSegments * 2 - 1);
                rulePath.strokeDashes = [dashLength, dashLength];
            }
    
            return rulePath;
        }
    
        /**
         * マスクの切り口に沿った眫線を䜜る耇合パスは䞭のパスごずに䜜る
         * @param {PageItem} maskPath - 元になるマスクのパス
         * @param {object} ruleSettings - { ruleDashed: boolean, dashSegments: number, roundCap: boolean }
         * @returns {PathItem[]} 䜜成した眫線のパス
         */
        function createEdgeRules(maskPath, ruleSettings) {
            var midY = getMaskMidY(maskPath);
            var subPaths = getSubPaths(maskPath);
            var rulePaths = [];
    
            for (var pathIndex = 0; pathIndex < subPaths.length; pathIndex++) {
                var rulePath = createEdgeRule(subPaths[pathIndex], midY, ruleSettings);
                if (rulePath) rulePaths.push(rulePath);
            }
            return rulePaths;
        }
    
        // =========================================
        // 組み立お / Assemble the parts
        // =========================================
    
        /**
         * 画像を耇補し、枡したパスでクリッピングマスクを䜜成する
         * @param {PageItem} maskPath - マスクに䜿うパス
         * @returns {GroupItem} 䜜成したクリップグルヌプ
         */
        function createClippedPart(maskPath) {
            var partImage = targetImage.duplicate(parentContainer, ElementPlacement.PLACEATBEGINNING);
    
            var clipGroup = parentContainer.groupItems.add();
            maskPath.move(clipGroup, ElementPlacement.PLACEATBEGINNING);
            partImage.move(clipGroup, ElementPlacement.PLACEATEND);
            clipGroup.clipped = true;
    
            return clipGroup;
        }
    
        /**
         * 眫線をパヌツずひず぀のグルヌプにたずめる
         * @param {GroupItem} clipGroup - クリップグルヌプ
         * @param {PathItem[]} rulePaths - たずめる眫線
         * @returns {PageItem} たずめたグルヌプ眫線がなければクリップグルヌプのたた
         */
        function groupWithRules(clipGroup, rulePaths) {
            if (!rulePaths.length) return clipGroup;
    
            var partGroup = parentContainer.groupItems.add();
            for (var ruleIndex = 0; ruleIndex < rulePaths.length; ruleIndex++) {
                rulePaths[ruleIndex].move(partGroup, ElementPlacement.PLACEATEND);
            }
            clipGroup.move(partGroup, ElementPlacement.PLACEATEND);
            return partGroup;
        }
    
        /**
         * 垯を取り陀いた䞊䞋のパヌツを䜜る
         * 䞊偎は䞋蟺を垯の䞊端に、䞋偎は同じ耇補の䞋蟺を垯の䞋端に合わせ、
         * それぞれ反察偎の蟺を画像の䞊端・䞋端に切りそろえる
         * @param {object} buildSettings - { warpStyleKey, warpPercent, gapPt, addRule, ruleDashed, dashSegments, roundCap, groupRules }
         * @returns {PageItem[]} 䜜成したクリップグルヌプず眫線
         */
        function buildParts(buildSettings) {
            var upperMaskPath = createMaskPath(bandTop + maskHeight, buildSettings.warpStyleKey, buildSettings.warpPercent);
            /* カヌブの䞭心を垯の䞊端に合わせる䞊昇は切り口が片寄るため */
            alignCutEdge(upperMaskPath, bandTop);
    
            var lowerMaskPath = upperMaskPath.duplicate(parentContainer, ElementPlacement.PLACEATBEGINNING);
            lowerMaskPath.translate(0, bandBottom - bandTop);
    
            /* 眫線は切りそろえる前の蟺から取り出す / take the rules before the far edge is flattened */
            var upperRules = buildSettings.addRule ? createEdgeRules(upperMaskPath, buildSettings) : [];
            var lowerRules = buildSettings.addRule ? createEdgeRules(lowerMaskPath, buildSettings) : [];
    
            flattenFarEdge(upperMaskPath, imageTop);
            flattenFarEdge(lowerMaskPath, imageBottom);
    
            var upperPart = createClippedPart(upperMaskPath);
            var lowerPart = createClippedPart(lowerMaskPath);
    
            /* 䞋偎を䞊ぞ動かし、指定の間隔をあける。䞋偎の眫線も䞀緒に動かす */
            var lowerShift = bandTop - bandBottom - buildSettings.gapPt;
            lowerPart.translate(0, lowerShift);
    
            var ruleIndex;
            for (ruleIndex = 0; ruleIndex < lowerRules.length; ruleIndex++) {
                lowerRules[ruleIndex].translate(0, lowerShift);
            }
    
            /* 眫線は切り口の䞊に出す / bring the rules in front of the parts */
            var rulePaths = upperRules.concat(lowerRules);
            for (ruleIndex = 0; ruleIndex < rulePaths.length; ruleIndex++) {
                rulePaths[ruleIndex].move(parentContainer, ElementPlacement.PLACEATBEGINNING);
            }
    
            if (buildSettings.groupRules) {
                return [groupWithRules(upperPart, upperRules), groupWithRules(lowerPart, lowerRules)];
            }
            return [upperPart, lowerPart].concat(rulePaths);
        }
    
        // =========================================
        // プレビュヌ / Preview
        // =========================================
    
        /* プレビュヌで䜜った物の控え / Items created for the preview */
        var previewItems = null;
    
        /**
         * プレビュヌを取り消しお元の衚瀺に戻す
         * @returns {void}
         */
        function clearPreview() {
            if (previewItems) {
                for (var itemIndex = 0; itemIndex < previewItems.length; itemIndex++) {
                    previewItems[itemIndex].remove();
                }
                previewItems = null;
            }
            targetImage.hidden = false;
            bandPath.hidden = false;
        }
    
        /**
         * 珟圚の倀でプレビュヌを䜜り盎す
         * 耇補は hidden 状態を匕き継ぐので、元アむテムを衚瀺したたた䜜っおから元を隠す
         * @param {object} buildSettings - { warpStyleKey, warpPercent, gapPt, addRule, ruleDashed, dashSegments, roundCap, groupRules }
         * @returns {void}
         */
        function refreshPreview(buildSettings) {
            clearPreview();
            previewItems = buildParts(buildSettings);
            targetImage.hidden = true;
            bandPath.hidden = true;
            doc.selection = null;
            app.redraw();
        }
    
        // =========================================
        // ダむアログ / Dialog
        // =========================================
    
        /**
         * 「トリミング」パネルを組み立おる
         * @param {Window} dialog - 远加先のダむアログ
         * @returns {object} パネルの入力コントロヌル
         */
        function buildTrimPanel(dialog) {
            var trimPanel = addPanel(dialog, "panel.trim");
    
            var warpStyleRow = addRadioRow(trimPanel, "fieldLabel.warpStyle", "tooltip.warpStyle",
                ["radio.flag", "radio.rise"], (DEFAULT_WARP_STYLE === "rise") ? 1 : 0);
            var warpAmountRow = addNumberFieldRow(trimPanel, "fieldLabel.warpAmount", "tooltip.warpAmount",
                String(DEFAULT_WARP_PERCENT), "%");
            var gapRow = addNumberFieldRow(trimPanel, "fieldLabel.gap", "tooltip.gap",
                formatFieldNumber(defaultGapValue), rulerUnit.label);
    
            return {
                styleRadios: warpStyleRow.radios,
                riseRadio: warpStyleRow.radios[1],
                warpAmountField: warpAmountRow.field,
                gapField: gapRow.field
            };
        }
    
        /**
         * 「省略線」パネルを組み立おる
         * @param {Window} dialog - 远加先のダむアログ
         * @returns {object} パネルの入力コントロヌル
         */
        function buildBreakLinePanel(dialog) {
            var breakLinePanel = addPanel(dialog, "panel.breakLine");
    
            var addRuleCheckbox = addCheckboxRow(breakLinePanel, "checkbox.addRule", "tooltip.addRule", DEFAULT_ADD_RULE);
            var ruleStyleRow = addRadioRow(breakLinePanel, "fieldLabel.ruleStyle", "tooltip.ruleStyle",
                ["radio.solid", "radio.dashed"], DEFAULT_RULE_DASHED ? 1 : 0);
            var dashSegmentsRow = addNumberFieldRow(breakLinePanel, "fieldLabel.dashSegments", "tooltip.dashSegments",
                String(DEFAULT_DASH_SEGMENTS));
            var strokeCapRow = addRadioRow(breakLinePanel, "fieldLabel.strokeCap", "tooltip.strokeCap",
                ["radio.buttCap", "radio.roundCap"], DEFAULT_ROUND_CAP ? 1 : 0);
            var groupRulesCheckbox = addCheckboxRow(breakLinePanel, "checkbox.groupRules", "tooltip.groupRules",
                DEFAULT_GROUP_RULES, true);
    
            return {
                addRuleCheckbox: addRuleCheckbox,
                styleRow: ruleStyleRow.row,
                styleRadios: ruleStyleRow.radios,
                dashedRadio: ruleStyleRow.radios[1],
                segmentsRow: dashSegmentsRow.row,
                segmentsField: dashSegmentsRow.field,
                capRow: strokeCapRow.row,
                capRadios: strokeCapRow.radios,
                roundCapRadio: strokeCapRow.radios[1],
                groupRulesCheckbox: groupRulesCheckbox
            };
        }
    
        /**
         * 切り口の圢・間隔・省略線を指定するダむアログを衚瀺する
         * @returns {object|null} 蚭定キャンセル時は null
         */
        function showSettingsDialog() {
            var dialog = new Window("dialog", getLabel("dialog.title"));
            dialog.orientation = "column";
            dialog.alignChildren = ["fill", "top"];
            dialog.margins = WINDOW_MARGINS;
            dialog.spacing = WINDOW_SPACING;
    
            var trimControls = buildTrimPanel(dialog);
            var ruleControls = buildBreakLinePanel(dialog);
            var buttonControls = addButtonRow(dialog);
    
            /**
             * 眫線たわりの行の有効・無効を切り替える
             * @returns {void}
             */
            function updateRuleRows() {
                var addRule = ruleControls.addRuleCheckbox.value;
                ruleControls.styleRow.enabled = addRule;
                ruleControls.segmentsRow.enabled = addRule && ruleControls.dashedRadio.value;
                ruleControls.capRow.enabled = addRule;
                ruleControls.groupRulesCheckbox.enabled = addRule;
            }
    
            /**
             * ダむアログの入力内容を読み取る倀は欄にそろえ盎す
             * @returns {object} 蚭定
             */
            function collectSettings() {
                var gapValue = readFieldValue(trimControls.gapField, clampGapValue);
                return {
                    warpStyleKey: trimControls.riseRadio.value ? "rise" : "flag",
                    warpPercent: readFieldValue(trimControls.warpAmountField, clampWarpPercent),
                    gapPt: gapValue * rulerUnit.pointsPerUnit,
                    addRule: ruleControls.addRuleCheckbox.value,
                    ruleDashed: ruleControls.dashedRadio.value,
                    dashSegments: readFieldValue(ruleControls.segmentsField, clampDashSegments),
                    roundCap: ruleControls.roundCapRadio.value,
                    groupRules: ruleControls.groupRulesCheckbox.value
                };
            }
    
            /**
             * 入力が倉わったらプレビュヌを䜜り盎す
             * @returns {void}
             */
            function onSettingChanged() {
                updateRuleRows();
                refreshPreview(collectSettings());
            }
    
            wireNumberField(trimControls.warpAmountField, clampWarpPercent, onSettingChanged);
            wireNumberField(trimControls.gapField, clampGapValue, onSettingChanged);
            wireNumberField(ruleControls.segmentsField, clampDashSegments, onSettingChanged);
            wireClickControls(trimControls.styleRadios
                .concat([ruleControls.addRuleCheckbox])
                .concat(ruleControls.styleRadios)
                .concat(ruleControls.capRadios)
                .concat([ruleControls.groupRulesCheckbox]), onSettingChanged);
    
            var dialogSettings = null;
            buttonControls.btnOK.onClick = function () {
                dialogSettings = collectSettings();
                dialog.close(1);
            };
            buttonControls.btnCancel.onClick = function () {
                dialog.close(0);
            };
    
            /* 開いた時点のプレビュヌを先に出す / Show the preview before the dialog appears */
            updateRuleRows();
            refreshPreview(collectSettings());
    
            return (dialog.show() === 1) ? dialogSettings : null;
        }
    
        // =========================================
        // 実行 / Run
        // =========================================
    
        var buildSettings = showSettingsDialog();
        clearPreview();
    
        if (!buildSettings) {
            selectItems([targetImage, bandPath]);
            return;
        }
    
        /* 確定実行。プレビュヌず同じ関数を通し、元画像ず垯のパスは圹目を終えるので削陀する */
        var finalItems = buildParts(buildSettings);
        targetImage.remove();
        bandPath.remove();
        selectItems(finalItems);
    })();
    

    アップデヌト履歎

    機胜远加・䞍具合修正を順次行なっおいたす。

    v1.0.2

    • 省略線の線幅を蚭定できるように

    • マスク図圢の高さ、䜍眮調敎を远加

    • レむアりト倉曎

    画像

    v1.0.4

    • 倧波片方だけ察応

    • スタむルに「䞊昇盎線」を远加

    画像

    次のバリ゚ヌションに察応したす。

    画像

    v1.0.5

    • カヌブに負の倀を蚱容

    v1.0.7

    • 幅の調敎を远加

    • UIの調敎

    • UI文蚀、ツヌルチップの再怜蚎

    画像

    v1.0.8

    • 「ゞグザグ」を远加

    画像

    v1.1.0

    • 切り口をアむコン化

    画像

    ダりンロヌド

     
     
    「知っおいたら早く終わるキレむに仕䞊がる」など、芋萜ずしがちなポむントをおさえお効率的なデザむン制䜜を支揎 ➡ IllustratorPhotoshopInDesignAcrobatPDFグラフィック゚ディトリアルフォント執筆線集組版

    あなたぞのおすすめ