แป้นพิมพ์ลัด

Blockly มีรีจิสทรีของแป้นพิมพ์ลัดที่แมปแป้น (หรือชุดแป้น เช่น ctrl-C) กับการดำเนินการ รีจิสทรีจะป้อนข้อมูลล่วงหน้าด้วยแป้นพิมพ์ลัดจำนวนหนึ่ง เช่น ctrl-C และ meta-C สำหรับการคัดลอก คุณเพิ่มและลบทางลัดจากรีจิสทรีได้

วิธีการทำงานของแป้นพิมพ์ลัด

รีจิสทรีแป้นพิมพ์ลัดมีออบเจ็กต์ที่จำลองแป้นพิมพ์ลัด เมื่อ ผู้ใช้กดแป้น (หรือชุดแป้น) Blockly จะทำดังนี้

1. ตรวจสอบรีจิสทรีเพื่อดูว่ามีทางลัดใดที่ใช้กับคีย์หรือไม่ หากแป้นพิมพ์ลัดมากกว่า 1 รายการใช้แป้นดังกล่าว ระบบจะลองใช้แป้นพิมพ์ลัดตามลำดับการลงทะเบียนย้อนหลัง กล่าวคือ ระบบจะลองใช้แป้นพิมพ์ลัดที่ลงทะเบียนล่าสุดก่อน

2. เรียกใช้ฟังก์ชัน preconditionFn ของทางลัด ซึ่งจะพิจารณาว่าทางลัดใช้ได้กับสถานการณ์ปัจจุบันหรือไม่ ตัวอย่างเช่น ทางลัดการคัดลอก จะมีผลกับบล็อกแต่ไม่มีผลกับพื้นที่ทำงาน หากใช้แป้นพิมพ์ลัดไม่ได้ Blockly จะลองใช้แป้นพิมพ์ลัดถัดไปในรายการ หากมี

3. เรียกใช้ฟังก์ชัน callback ของทางลัด ซึ่งจะดำเนินการกับ การทำงานของทางลัด ตัวอย่างเช่น ทางลัดคัดลอกจะทำสำเนาของออบเจ็กต์ที่โฟกัสอยู่ ในปัจจุบัน เช่น บล็อก หากฟังก์ชันนี้แสดงผล true ระบบจะหยุดการประมวลผล หากส่งคืน false Blockly จะลองใช้แป้นพิมพ์ลัดถัดไปในรายการ (หากมี)

ขอบเขต

ออบเจ็กต์ A Scope จะระบุคอมโพเนนต์ Blockly ที่โฟกัสอยู่ในขณะนี้ ระบบจะส่งออบเจ็กต์ขอบเขต ไปยัง preconditionFn และ callback ซึ่งจะใช้ออบเจ็กต์ดังกล่าวเพื่อพิจารณาว่า แป้นพิมพ์ลัดใช้กับคอมโพเนนต์ใดคอมโพเนนต์หนึ่งหรือไม่ และหากใช้ จะใช้อย่างไร

หากต้องการใช้ออบเจ็กต์ Scope ให้ใช้พร็อพเพอร์ตี้ focusedNode ของออบเจ็กต์ นี่คือออบเจ็กต์ที่ ใช้IFocusableNode อินเทอร์เฟซนี้ จะใช้งานโดยคอมโพเนนต์ Blockly ทั้งหมดที่ผู้ใช้สามารถโฟกัสได้ ซึ่งรวมถึงพื้นที่ทำงาน บล็อก ฟิลด์ ความคิดเห็น และคอมโพเนนต์ที่กำหนดเองของคุณเอง ดูข้อมูลเพิ่มเติมได้ที่ระบบโฟกัส

เช่น preconditionFn อาจใช้ focusedNode เพื่อให้แน่ใจว่าแป้นพิมพ์ลัด จะใช้กับบล็อกเท่านั้น

preconditionFn(workspace, scope) {
  return (scope.focusedNode instanceof Blockly.BlockSvg);
}

อินเทอร์เฟซ KeyboardShortcut

ออบเจ็กต์ในรีจิสทรีทางลัดจะใช้ KeyboardShortcut อินเทอร์เฟซ ซึ่งมีพร็อพเพอร์ตี้ต่อไปนี้

name (ต้องระบุ)

ชื่อที่ไม่ซ้ำกันสำหรับทางลัด ซึ่งไม่ได้แสดงต่อผู้ใช้และไม่จำเป็นต้อง เป็นข้อความที่มนุษย์อ่านได้ ไม่ควรแปล

const logFieldsShortcut = {
  name: 'logFields',
  // ...
};

preconditionFn (ไม่บังคับ)

Blockly จะเรียกใช้ฟังก์ชันนี้เพื่อพิจารณาว่าแป้นพิมพ์ลัดใช้กับสถานการณ์ปัจจุบันได้หรือไม่ หากแสดงผลเป็น true Blockly จะเรียกใช้ callback หากส่งคืน false Blockly จะไม่สนใจแป้นพิมพ์ลัดนี้ เช่น

const logFieldsShortcut = {
  // ...
  preconditionFn(workspace, scope) {
    // This shortcut only applies to blocks.
    return (scope.focusedNode instanceof Blockly.BlockSvg);
  },
  // ...
};

ทางลัดสามารถละเว้นฟังก์ชันนี้ได้หากทางลัดใช้ได้เสมอ (ไม่ปกติ) ทางลัดไม่ควรละเว้นฟังก์ชันนี้ แล้วดำเนินการตามเงื่อนไขใน callback การทำเช่นนี้จะป้องกันไม่ให้ Blockly ทำสิ่งต่างๆ เช่น สร้างเมนูความช่วยเหลือตามบริบท ที่แสดงแป้นพิมพ์ลัดที่ใช้ได้

Callback (ไม่บังคับ)

ฟังก์ชันนี้จะดำเนินการที่เชื่อมโยงกับแป้นพิมพ์ลัด โดยจะเรียกใช้ก็ต่อเมื่อ preconditionFn แสดงผล true หรือไม่มีอยู่ พารามิเตอร์ของฟังก์ชันนี้มีดังนี้

• workspace: WorkspaceSvg ปัจจุบัน
• e: Event ที่เริ่มทางลัด
• shortcut: KeyboardShortcut เอง
• scope: Scope ที่ใช้ทางลัด

โดยจะแสดง true หากสำเร็จ และ false หากไม่สำเร็จ

เช่น

const logFieldsShortcut = {
  // ...
  callback(workspace, event, shortcut, scope) {
    // preconditionFn required focusedNode to be a BlockSvg.
    for (input of scope.focusedNode.inputList) {
      // Log the values of all named fields. (Label fields usually don't have names.)
      for (field of input.fieldRow) {
        if (field.name) {
          console.log(field.name + ': ' + field.getText());
        }
      }
    }
    return true;
  },
  // ...
};

แม้ว่า callback จะเป็นตัวเลือก แต่โดยทั่วไปแล้วไม่มีเหตุผลที่จะไม่ใช้

keyCodes (ไม่บังคับ)

อาร์เรย์ของคีย์ (หรือชุดคีย์) ที่เปิดใช้งานแป้นพิมพ์ลัดนี้ หากต้องการระบุคีย์ ให้ใช้รหัสคีย์ใน Blockly.utils.KeyCodes เช่น

const logFieldsShortcut = {
  // ...
  keyCodes: [Blockly.utils.KeyCodes.L],
  // ...
};

หากต้องการแมปคีย์เพิ่มเติมกับแป้นพิมพ์ลัดที่มีอยู่ เช่น หากต้องการเพิ่มคีย์ไปยังแป้นพิมพ์ลัดเริ่มต้น คุณสามารถเรียกใช้ Blockly.ShortcutRegistry.registry.addKeyMapping ได้ ซึ่งเป็นสิ่งที่พบได้ไม่บ่อยนัก

ชุดคีย์

หากแป้นพิมพ์ลัดเปิดใช้งานด้วยชุดแป้น เช่น กด Control และ C พร้อมกัน ให้สร้างรหัสแป้นแบบอนุกรมโดยเรียกใช้ Blockly.ShortcutRegistry.registry.createSerializedKey

const ctrlC = Blockly.ShortcutRegistry.registry.createSerializedKey(
  Blockly.utils.KeyCodes.C,       // Keycode of main key
  [Blockly.utils.KeyCodes.CTRL],  // Array of modifier keys
);

const copyShortcut = {
  // ...
  keyCodes: [ctrlC], // Use the serialized keycode
  // ...
};

Control และ Meta

ใน Windows แป้นพิมพ์ลัดหลายรายการจะเปิดใช้งานด้วยปุ่ม Control ใน Mac แป้นพิมพ์ลัดเหล่านี้จะใช้ปุ่ม Command แทน ซึ่งระบบจะจดจำเป็นรหัสแป้น META หากต้องการรองรับทั้ง 2 ระบบปฏิบัติการ ให้ลงทะเบียนแป้นพิมพ์ลัดด้วยทั้งรหัสคีย์ CTRL และรหัสคีย์ META

const ctrlC = Blockly.ShortcutRegistry.registry.createSerializedKey(
  Blockly.utils.KeyCodes.C,
  [Blockly.utils.KeyCodes.CTRL],
);
const metaC = Blockly.ShortcutRegistry.registry.createSerializedKey(
  Blockly.utils.KeyCodes.C,
  [Blockly.utils.KeyCodes.META],
);

const copyShortcut = {
  // ...
  keyCodes: [ctrlC, metaC],
  // ...
};

หมายเหตุการใช้งาน

ตัวแฮนเดิลเหตุการณ์ของแป้นพิมพ์ของ Blockly ใช้พร็อพเพอร์ตี้ keycode ของ KeyboardEvent แม้ว่าจะเลิกใช้งานแล้วก็ตาม

allowCollision (ไม่บังคับ)

โดยค่าเริ่มต้น คุณจะลงทะเบียนแป้นพิมพ์ลัดสำหรับแป้นหรือชุดแป้นที่กดร่วมกันได้เพียงรายการเดียว การตั้งค่าพร็อพเพอร์ตี้นี้เป็น true จะช่วยให้คุณลงทะเบียนแป้น (หรือชุดแป้นที่กดร่วมกัน) ได้แม้ว่าจะมีการลงทะเบียนแป้นพิมพ์ลัดที่มีแป้น (หรือชุดแป้นที่กดร่วมกัน) เดียวกันอยู่แล้วก็ตาม

โปรดทราบว่าพร็อพเพอร์ตี้นี้จะมีผลเมื่อพยายามลงทะเบียนแป้นพิมพ์ลัดนี้เท่านั้น แต่จะไม่ป้องกันไม่ให้แป้นพิมพ์ลัดอื่นๆ ใช้แป้น (หรือชุดแป้น) เดียวกัน จะลงทะเบียนได้หรือไม่ขึ้นอยู่กับค่าของพร็อพเพอร์ตี้ allowCollision

ไม่ว่าจะลงทะเบียนแป้นพิมพ์ลัดกี่รายการสำหรับแป้นหรือชุดแป้นที่กำหนด ระบบจะดำเนินการได้สำเร็จเพียงรายการเดียวเท่านั้น ระบบจะลองใช้ทางลัดตามลำดับการลงทะเบียนย้อนหลัง (จากที่ลงทะเบียนล่าสุดไปจนถึงที่ลงทะเบียนครั้งแรก) หลังจากฟังก์ชันใดฟังก์ชันหนึ่งส่งคืน true จากการเรียกกลับแล้ว ระบบจะไม่ลองใช้แป้นพิมพ์ลัดอื่นๆ

ข้อมูลเมตา (ไม่บังคับ)

ซึ่งเป็นออบเจ็กต์ที่กำหนดเองซึ่งมีข้อมูลเพิ่มเติม โดยมีให้บริการ แก่ callback ผ่านพารามิเตอร์ shortcut

เพิ่ม ลบ และแก้ไขทางลัด

หากต้องการเพิ่มแป้นพิมพ์ลัดใหม่ ให้เรียกใช้ Blockly.ShortcutRegistry.registry.register ดังนี้

Blockly.ShortcutRegistry.registry.register(logFieldsShortcut);

ฟังก์ชันนี้มีพารามิเตอร์ที่ 2 (allowOverrides) ซึ่งช่วยให้คุณแทนที่ ทางลัดที่มีอยู่ด้วยทางลัดที่มีชื่อเดียวกันได้ โปรดทราบว่าฟีเจอร์นี้แตกต่างจาก KeyboardShortcut.allowCollision ซึ่งช่วยให้คุณเพิ่มแป้นพิมพ์ลัด ที่มีชื่อต่างกันได้ แต่ใช้แป้นหรือชุดแป้นที่กดร่วมกันเดียวกันกับแป้นพิมพ์ลัดที่มีอยู่

หากต้องการลบแป้นพิมพ์ลัด ให้เรียกใช้ Blockly.ShortcutRegistry.registry.unregister และส่งชื่อของ แป้นพิมพ์ลัด

Blockly.ShortcutRegistry.registry.unregister('logFields');

คุณไม่สามารถแก้ไขแป้นพิมพ์ลัดในตำแหน่งได้ แต่คุณต้องลบ แป้นพิมพ์ลัดที่มีอยู่และเพิ่มแป้นพิมพ์ลัดใหม่ เช่น

// Get the existing shortcut. getRegistry returns an object keyed by shortcut name.
const allShortcuts = Blockly.ShortcutRegistry.registry.getRegistry();
const modLogFieldsShortcut = allShortcuts[logFieldsShortcut.name];
// Apply the shortcut only to math blocks,
modLogFieldsShortcut.preconditionFn = function (workspace, scope) {
  return (scope.focusedNode instanceof Blockly.BlockSvg &&
          scope.focusedNode.type.startsWith('math_'));
}
// Delete the existing shortcut and add the modified shortcut.
Blockly.ShortcutRegistry.registry.unregister(logFieldsShortcut.name);
Blockly.ShortcutRegistry.registry.register(modLogFieldsShortcut);

ทางลัดค่าเริ่มต้น

รีจิสทรีของทางลัดจะมีการป้อนข้อมูลทางลัดจำนวนหนึ่งไว้ล่วงหน้า คุณดูรายการเหล่านี้ได้ที่ https://github.com/google/blockly/blob/master/core/shortcut_items.ts แป้นพิมพ์ลัดกำหนดไว้ในregisterXxxxฟังก์ชัน

แป้นพิมพ์ลัดสำหรับการไปยังส่วนต่างๆ

ปลั๊กอินการไปยังส่วนต่างๆ ด้วยแป้นพิมพ์ มีแป้นพิมพ์ลัดที่ช่วยให้ผู้ใช้ไปยังส่วนต่างๆ ของ Blockly ด้วยแป้นพิมพ์ได้ เช่น การใช้ปุ่มลูกศร การไปยังส่วนต่างๆ ด้วยแป้นพิมพ์เป็นสิ่งจำเป็นสำหรับผู้ใช้ที่ไม่สามารถใช้เมาส์ได้ เช่น ผู้ที่มีความบกพร่องทางการเคลื่อนไหวหรือความบกพร่องทางสายตา นอกจากนี้ ยังมีประโยชน์ สำหรับผู้ใช้ขั้นสูงที่อาจต้องการใช้แป้นพิมพ์ลัดเพื่อประสิทธิภาพด้วย