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

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 ทำสิ่งต่างๆ เช่น สร้างเมนูความช่วยเหลือตามบริบท ที่แสดงแป้นพิมพ์ลัดที่ใช้ได้

การเรียกกลับ (ไม่บังคับ)

ฟังก์ชันนี้จะดำเนินการที่เชื่อมโยงกับทางลัด โดยจะเรียกใช้ก็ต่อเมื่อ 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/RaspberryPiFoundation/blockly/blob/main/core/shortcut_items.ts แป้นพิมพ์ลัดกำหนดไว้ในregisterXxxxฟังก์ชัน

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

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