Max OS 0.3
Loading...
Searching...
No Matches
Public Types | Public Member Functions | List of all members
MaxOS::drivers::peripherals::KeyboardInterpreterEN_US Class Reference

Interprets the scan codes from the keyboard for the EN_US keyboard layout. More...

#include <keyboard.h>

Inheritance diagram for MaxOS::drivers::peripherals::KeyboardInterpreterEN_US:
MaxOS::drivers::peripherals::KeyboardInterpreter MaxOS::common::InputStreamEventHandler< uint8_t > MaxOS::common::EventManager< KeyboardEvents >

Public Types

enum class  KeyCodeEN_US {
  escape = 0x01 , f1 = 0x3B , f2 = 0x3C , f3 = 0x3D ,
  f4 = 0x3E , f5 = 0x3F , f6 = 0x40 , f7 = 0x41 ,
  f8 = 0x42 , f9 = 0x43 , f10 = 0x44 , f11 = 0x57 ,
  f12 = 0x58 , printScreen = 0x37 , scrollLock = 0x46 , pauseBreak = 0x45 ,
  squigglyLine = 0x29 , one = 0x02 , two = 0x03 , three = 0x04 ,
  four = 0x05 , five = 0x06 , six = 0x07 , seven = 0x08 ,
  eight = 0x09 , nine = 0x0A , zero = 0x0B , minus = 0x0C ,
  equals = 0x0D , backspace = 0x0E , insert = 0x52 , home = 0x47 ,
  pageUp = 0x49 , numberPadLock = 0x45 , numberPadForwardSlash = 0x35 , numberPadMultiply = 0x37 ,
  numberPadMinus = 0x4A , tab = 0x0F , Q = 0x10 , W = 0x11 ,
  E = 0x12 , R = 0x13 , T = 0x14 , Y = 0x15 ,
  U = 0x16 , I = 0x17 , O = 0x18 , P = 0x19 ,
  openSquareBracket = 0x1A , closeSquareBracket = 0x1B , backslash = 0x2B , deleteKey = 0x53 ,
  end = 0x4F , pageDown = 0x51 , numberPadSeven = 0x47 , numberPadEight = 0x48 ,
  numberPadNine = 0x49 , numberPadPlus = 0x4E , capsLock = 0x3A , A = 0x1E ,
  S = 0x1F , D = 0x20 , F = 0x21 , G = 0x22 ,
  H = 0x23 , J = 0x24 , K = 0x25 , L = 0x26 ,
  semicolon = 0x27 , apostrophe = 0x28 , enter = 0x1C , numberPadFour = 0x4B ,
  numberPadFive = 0x4C , numberPadSix = 0x4D , leftShift = 0x2A , Z = 0x2C ,
  X = 0x2D , C = 0x2E , V = 0x2F , B = 0x30 ,
  N = 0x31 , M = 0x32 , comma = 0x33 , fullStop = 0x34 ,
  forwardSlash = 0x35 , rightShift = 0x36 , upArrow = 0x48 , numberPadOne = 0x4F ,
  numberPadTwo = 0x50 , numberPadThree = 0x51 , numberPadEnter = 0x1C , leftControl = 0x1D ,
  leftOS = 0x5B , leftAlt = 0x38 , space = 0x39 , rightAlt = 0x38 ,
  function = 0x5D , rightControl = 0x1D , leftArrow = 0x4B , downArrow = 0x50 ,
  rightArrow = 0x4D , numberPadZero = 0x52 , numberPadFullStop = 0x53
}
 The scan codes for the EN_US keyboard layout. More...
 

Public Member Functions

 KeyboardInterpreterEN_US ()
 Construct a new Keyboard Interpreter for the EN_US layout.
 
void on_stream_read (uint8_t scan_code) final
 Handle the key down event.
 
- Public Member Functions inherited from MaxOS::drivers::peripherals::KeyboardInterpreter
 KeyboardInterpreter ()
 Construct a new Keyboard Interpreter object.
 
void on_key_read (bool, const KeyboardState &, KeyCode)
 Handle the key event.
 
- Public Member Functions inherited from MaxOS::common::InputStreamEventHandler< uint8_t >
 InputStreamEventHandler ()
 _______________________________________________TEMPLATES_________________________________________________________________///
 
 ~InputStreamEventHandler ()
 Destroys the InputStreamProcessor and disconnects it from all streams.
 
virtual void on_stream_read (uint8_t)
 Called when data is read from a stream (overridden by subclasses)
 
virtual void on_end_of_stream (GenericInputStream< uint8_t > *)
 Called when a stream has finished. Removes the stream from the array of streams.
 
- Public Member Functions inherited from MaxOS::common::EventManager< KeyboardEvents >
void connect_event_handler (EventHandler< KeyboardEvents > *handler)
 connect an event handler to the event manager if it is not already connected
 
void disconnect_event_handler (EventHandler< KeyboardEvents > *handler)
 disconnect an event handler from the event manager if it is connected
 
Vector< Event< KeyboardEvents > * > raise_event (Event< KeyboardEvents > *event)
 Calls the on_event function of all the event m_handlers connected to the event manager and returns a list of the results.
 

Additional Inherited Members

- Protected Attributes inherited from MaxOS::drivers::peripherals::KeyboardInterpreter
KeyboardState m_keyboard_state
 The current state of what special keys are pressed on the keyboard.
 
bool m_next_is_first_extended_code = false
 If true, the next code should be interpreted as an extended code (set when receiving 0xE0)
 
uint8_t m_extended_scan_code_bytes = 0
 How many bytes are left to read for the current extended scan code.
 
uint16_t m_extended_code_buffer = 0
 The storage for scan codes that take more than one byte.
 
- Protected Attributes inherited from MaxOS::common::InputStreamEventHandler< uint8_t >
common::Vector< GenericInputStream< uint8_t > * > m_generic_input_streams
 List of streams being observed by this handler.
 
- Protected Attributes inherited from MaxOS::common::EventManager< KeyboardEvents >
Vector< EventHandler< KeyboardEvents > * > m_handlers
 

Detailed Description

Interprets the scan codes from the keyboard for the EN_US keyboard layout.

Definition at line 310 of file keyboard.h.

Member Enumeration Documentation

◆ KeyCodeEN_US

enum class MaxOS::drivers::peripherals::KeyboardInterpreterEN_US::KeyCodeEN_US
strong

The scan codes for the EN_US keyboard layout.

Definition at line 318 of file keyboard.h.

318 {
319 // First Row
320 escape = 0x01,
321 f1 = 0x3B,
322 f2 = 0x3C,
323 f3 = 0x3D,
324 f4 = 0x3E,
325 f5 = 0x3F,
326 f6 = 0x40,
327 f7 = 0x41,
328 f8 = 0x42,
329 f9 = 0x43,
330 f10 = 0x44,
331 f11 = 0x57,
332 f12 = 0x58,
333 printScreen = 0x37,
334 scrollLock = 0x46,
335 pauseBreak = 0x45,
336
337 // Second Row
338 squigglyLine = 0x29,
339 one = 0x02,
340 two = 0x03,
341 three = 0x04,
342 four = 0x05,
343 five = 0x06,
344 six = 0x07,
345 seven = 0x08,
346 eight = 0x09,
347 nine = 0x0A,
348 zero = 0x0B,
349 minus = 0x0C,
350 equals = 0x0D,
351 backspace = 0x0E,
352 insert = 0x52,
353 home = 0x47,
354 pageUp = 0x49,
355 numberPadLock = 0x45,
356 numberPadForwardSlash = 0x35,
357 numberPadMultiply = 0x37,
358 numberPadMinus = 0x4A,
359
360 // Third Row
361 tab = 0x0F,
362 Q = 0x10,
363 W = 0x11,
364 E = 0x12,
365 R = 0x13,
366 T = 0x14,
367 Y = 0x15,
368 U = 0x16,
369 I = 0x17,
370 O = 0x18,
371 P = 0x19,
372 openSquareBracket = 0x1A,
373 closeSquareBracket = 0x1B,
374 backslash = 0x2B,
375 deleteKey = 0x53,
376 end = 0x4F,
377 pageDown = 0x51,
378 numberPadSeven = 0x47,
379 numberPadEight = 0x48,
380 numberPadNine = 0x49,
381 numberPadPlus = 0x4E,
382
383 // Fourth Row
384 capsLock = 0x3A,
385 A = 0x1E,
386 S = 0x1F,
387 D = 0x20,
388 F = 0x21,
389 G = 0x22,
390 H = 0x23,
391 J = 0x24,
392 K = 0x25,
393 L = 0x26,
394 semicolon = 0x27,
395 apostrophe = 0x28,
396 enter = 0x1C,
397 numberPadFour = 0x4B,
398 numberPadFive = 0x4C,
399 numberPadSix = 0x4D,
400
401 // Fifth Row
402 leftShift = 0x2A,
403 Z = 0x2C,
404 X = 0x2D,
405 C = 0x2E,
406 V = 0x2F,
407 B = 0x30,
408 N = 0x31,
409 M = 0x32,
410 comma = 0x33,
411 fullStop = 0x34,
412 forwardSlash = 0x35,
413 rightShift = 0x36,
414 upArrow = 0x48,
415 numberPadOne = 0x4F,
416 numberPadTwo = 0x50,
417 numberPadThree = 0x51,
418 numberPadEnter = 0x1C,
419
420 // Sixth Row
421 leftControl = 0x1D,
422 leftOS = 0x5B,
423 leftAlt = 0x38,
424 space = 0x39,
425 rightAlt = 0x38,
426 function = 0x5D,
427 rightControl = 0x1D,
428 leftArrow = 0x4B,
429 downArrow = 0x50,
430 rightArrow = 0x4D,
431 numberPadZero = 0x52,
432 numberPadFullStop = 0x53
433 };
MaxOS::drivers::peripherals::KeyCode::f1
@ f1
OTHER CODES THAT ARE NOT CHARACTERS ///.

Constructor & Destructor Documentation

◆ KeyboardInterpreterEN_US()

KeyboardInterpreterEN_US::KeyboardInterpreterEN_US ( )

Construct a new Keyboard Interpreter for the EN_US layout.

Definition at line 156 of file keyboard.cpp.

157: KeyboardInterpreter()
158{
159
160}
MaxOS::drivers::peripherals::KeyboardInterpreter::KeyboardInterpreter
KeyboardInterpreter()
Construct a new Keyboard Interpreter object.
Definition keyboard.cpp:128

Member Function Documentation

◆ on_stream_read()

void KeyboardInterpreterEN_US::on_stream_read ( uint8_t  scan_code)
final

Handle the key down event.

Parameters
scan_codeThe scan code of the key that was pressed
Todo:
Probably a better way to do this (investigate when adding more keyboard layouts)

First row

Second row

Fourth row

Fifth row

Sixth row

Definition at line 171 of file keyboard.cpp.

171 {
172
173
174 // Check if the key was released
175 bool released = (scan_code & 0x80)
176 && (m_extended_scan_code_bytes || (scan_code != 0xe1))
177 && (m_next_is_first_extended_code || (scan_code != 0xe0));
178
179 // Clear the released bit
180 if (released)
181 scan_code &= ~0x80;
182
183 // Start of a scan code that takes more than one byte
184 if (scan_code == 0xe0) {
185 m_next_is_first_extended_code = true;
186 return;
187 }
188
189 // Handle extended scan codes
190 ScanCodeType type = ScanCodeType::REGULAR;
191 if (m_next_is_first_extended_code) {
192
193 type = ScanCodeType::EXTENDED;
194 m_next_is_first_extended_code = false;
195
196 // Check if the scan_code represents a shift key and return (fake shift)
197 if ((KeyboardInterpreterEN_US::KeyCodeEN_US) scan_code == KeyCodeEN_US::leftShift ||
198 (KeyboardInterpreterEN_US::KeyCodeEN_US) scan_code == KeyCodeEN_US::rightShift)
199 return;
200 }
201
202 // The scan code takes three bytes
203 if (scan_code == 0xe1) {
204 m_extended_scan_code_bytes = 1;
205 return;
206 }
207
208 // Take the second byte of a three-byte scan code and wait for the last byte (if applicable)
209 if (m_extended_scan_code_bytes == 1) {
210 m_extended_scan_code_bytes = 2;
211 m_extended_code_buffer = scan_code;
212 return;
213 }
214
215 // Take the last byte of a three-byte scan code
216 if (m_extended_scan_code_bytes == 2) {
217 type = ScanCodeType::EXTENDED;
218 m_extended_scan_code_bytes = 0;
219 m_extended_code_buffer |= (((uint16_t) scan_code) << 8);
220 }
221
222 // Scan code value manipulations
223 bool is_shifting = this->m_keyboard_state.left_shift || this->m_keyboard_state.right_shift;
224 bool should_be_upper_case = is_shifting != this->m_keyboard_state.caps_lock;
225
226 if (type == ScanCodeType::REGULAR)
227 switch ((KeyCodeEN_US) scan_code) {
228
230 case KeyCodeEN_US::escape:
231 on_key_read(released, this->m_keyboard_state, KeyCode::escape);
232 break;
233
234 case KeyCodeEN_US::f1:
235 on_key_read(released, this->m_keyboard_state, KeyCode::f1);
236 break;
237
238 case KeyCodeEN_US::f2:
239 on_key_read(released, this->m_keyboard_state, KeyCode::f2);
240 break;
241
242 case KeyCodeEN_US::f3:
243 on_key_read(released, this->m_keyboard_state, KeyCode::f3);
244 break;
245
246 case KeyCodeEN_US::f4:
247 on_key_read(released, this->m_keyboard_state, KeyCode::f4);
248 break;
249
250 case KeyCodeEN_US::f5:
251 on_key_read(released, this->m_keyboard_state, KeyCode::f5);
252 break;
253
254 case KeyCodeEN_US::f6:
255 on_key_read(released, this->m_keyboard_state, KeyCode::f6);
256 break;
257
258 case KeyCodeEN_US::f7:
259 on_key_read(released, this->m_keyboard_state, KeyCode::f7);
260 break;
261
262 case KeyCodeEN_US::f8:
263 on_key_read(released, this->m_keyboard_state, KeyCode::f8);
264 break;
265
266 case KeyCodeEN_US::f9:
267 on_key_read(released, this->m_keyboard_state, KeyCode::f9);
268 break;
269
270 case KeyCodeEN_US::f10:
271 on_key_read(released, this->m_keyboard_state, KeyCode::f10);
272 break;
273
274 case KeyCodeEN_US::f11:
275 on_key_read(released, this->m_keyboard_state, KeyCode::f11);
276 break;
277
278 case KeyCodeEN_US::f12:
279 on_key_read(released, this->m_keyboard_state, KeyCode::f12);
280 break;
281
282 case KeyCodeEN_US::printScreen:
283 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock ? KeyCode::numberPadMultiply : KeyCode::printScreen);
284 break;
285
286 case KeyCodeEN_US::scrollLock:
287 on_key_read(released, this->m_keyboard_state, KeyCode::scrollLock);
288 break;
289
291 case KeyCodeEN_US::squigglyLine:
292 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::squigglyLine : KeyCode::slantedApostrophe);
293 break;
294
295 case KeyCodeEN_US::one:
296 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::exclamationMark : KeyCode::one);
297 break;
298
299 case KeyCodeEN_US::two:
300 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::atSign : KeyCode::two);
301 break;
302
303 case KeyCodeEN_US::three:
304 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::hash : KeyCode::three);
305 break;
306
307 case KeyCodeEN_US::four:
308 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::dollarSign : KeyCode::four);
309 break;
310
311 case KeyCodeEN_US::five:
312 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::percentSign : KeyCode::five);
313 break;
314
315 case KeyCodeEN_US::six:
316 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::powerSign : KeyCode::six);
317 break;
318
319 case KeyCodeEN_US::seven:
320 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::andSign : KeyCode::seven);
321 break;
322
323 case KeyCodeEN_US::eight:
324 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::multiply : KeyCode::eight);
325 break;
326
327 case KeyCodeEN_US::nine:
328 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::openBracket : KeyCode::nine);
329 break;
330
331 case KeyCodeEN_US::zero:
332 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::closeBracket : KeyCode::zero);
333 break;
334
335 case KeyCodeEN_US::minus:
336 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::underscore : KeyCode::minus);
337 break;
338
339 case KeyCodeEN_US::equals:
340 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::plus : KeyCode::equals);
341 break;
342
343 case KeyCodeEN_US::backspace:
344 on_key_read(released, this->m_keyboard_state, KeyCode::backspace);
345 break;
346
347 case KeyCodeEN_US::insert:
348 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock ? KeyCode::numberPadZero : KeyCode::insert);
349 break;
350
351 case KeyCodeEN_US::home:
352 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock
353 ? KeyCode::numberPadSeven : KeyCode::home);
354 break;
355
356 case KeyCodeEN_US::pageUp:
357 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock ? KeyCode::numberPadNine : KeyCode::pageUp);
358 break;
359
360 case KeyCodeEN_US::numberPadLock:
361
362 // Ensure this is not a repeat
363 if (!released) {
364 this->m_keyboard_state.number_pad_lock = !this->m_keyboard_state.number_pad_lock;
365 }
366 on_key_read(released, this->m_keyboard_state, KeyCode::numberPadLock);
367 break;
368
369 case KeyCodeEN_US::numberPadForwardSlash:
370
371 // Check if number pad lock is on
372 if (this->m_keyboard_state.number_pad_lock) {
373 on_key_read(released, this->m_keyboard_state, KeyCode::numberPadForwardSlash);
374 } else {
375
376 // Normal Forward Slash
377 on_key_read(released, this->m_keyboard_state,
378 should_be_upper_case ? KeyCode::questionMark : KeyCode::forwardSlash);
379 }
380 break;
381
382 // Number Pad Multiply is same as print screen
383
384 case KeyCodeEN_US::numberPadMinus:
385 on_key_read(released, this->m_keyboard_state, KeyCode::numberPadMinus);
386 break;
387
388 // Third row
389 case KeyCodeEN_US::tab:
390 on_key_read(released, this->m_keyboard_state, KeyCode::tab);
391 break;
392
393 case KeyCodeEN_US::Q:
394 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::Q : KeyCode::q);
395 break;
396
397 case KeyCodeEN_US::W:
398 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::W : KeyCode::w);
399 break;
400
401 case KeyCodeEN_US::E:
402 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::E : KeyCode::e);
403 break;
404
405 case KeyCodeEN_US::R:
406 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::R : KeyCode::r);
407 break;
408
409 case KeyCodeEN_US::T:
410 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::T : KeyCode::t);
411 break;
412
413 case KeyCodeEN_US::Y:
414 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::Y : KeyCode::y);
415 break;
416
417 case KeyCodeEN_US::U:
418 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::U : KeyCode::u);
419 break;
420
421 case KeyCodeEN_US::I:
422 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::I : KeyCode::i);
423 break;
424
425 case KeyCodeEN_US::O:
426 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::O : KeyCode::o);
427 break;
428
429 case KeyCodeEN_US::P:
430 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::P : KeyCode::p);
431 break;
432
433 case KeyCodeEN_US::openSquareBracket:
434 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::openCurlyBracket : KeyCode::openSquareBracket);
435 break;
436
437 case KeyCodeEN_US::closeSquareBracket:
438 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::closeCurlyBracket : KeyCode::closeSquareBracket);
439 break;
440
441 case KeyCodeEN_US::backslash:
442 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::lineThing : KeyCode::backslash);
443 break;
444
445 case KeyCodeEN_US::deleteKey:
446 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock
447 ? KeyCode::numberPadFullStop : KeyCode::deleteKey);
448 break;
449
450 case KeyCodeEN_US::end:
451 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock ? KeyCode::numberPadOne : KeyCode::end);
452 break;
453
454 case KeyCodeEN_US::pageDown:
455 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock
456 ? KeyCode::numberPadThree : KeyCode::pageDown);
457 break;
458
459 // Number pad 7 is same as home
460
461 case KeyCodeEN_US::numberPadEight:
462 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock ? KeyCode::numberPadEight : KeyCode::upArrow);
463 break;
464
465 // Number pad 9 is same as page up
466
467 case KeyCodeEN_US::numberPadPlus:
468 on_key_read(released, this->m_keyboard_state, KeyCode::numberPadPlus);
469 break;
470
472 case KeyCodeEN_US::capsLock:
473 // Ensure this is not a repeat
474 if (!released) {
475 this->m_keyboard_state.caps_lock = !this->m_keyboard_state.caps_lock;
476 }
477
478 on_key_read(released, this->m_keyboard_state, KeyCode::capsLock);
479 break;
480
481 case KeyCodeEN_US::A:
482 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::A : KeyCode::a);
483 break;
484
485 case KeyCodeEN_US::S:
486 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::S : KeyCode::s);
487 break;
488
489 case KeyCodeEN_US::D:
490 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::D : KeyCode::d);
491 break;
492
493 case KeyCodeEN_US::F:
494 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::F : KeyCode::f);
495 break;
496
497 case KeyCodeEN_US::G:
498 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::G : KeyCode::g);
499 break;
500
501 case KeyCodeEN_US::H:
502 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::H : KeyCode::h);
503 break;
504
505 case KeyCodeEN_US::J:
506 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::J : KeyCode::j);
507 break;
508
509 case KeyCodeEN_US::K:
510 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::K : KeyCode::k);
511 break;
512
513 case KeyCodeEN_US::L:
514 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::L : KeyCode::l);
515 break;
516
517 case KeyCodeEN_US::semicolon:
518 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::colon : KeyCode::semicolon);
519 break;
520
521 case KeyCodeEN_US::apostrophe:
522 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::quotationMark : KeyCode::apostrophe);
523 break;
524
525 case KeyCodeEN_US::enter:
526 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock ? KeyCode::numberPadEnter : KeyCode::enter);
527 break;
528
529 case KeyCodeEN_US::numberPadFour:
530 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock ? KeyCode::numberPadFour : KeyCode::leftArrow);
531 break;
532
533 case KeyCodeEN_US::numberPadFive:
534 on_key_read(released, this->m_keyboard_state, KeyCode::numberPadFive);
535 break;
536
537 case KeyCodeEN_US::numberPadSix:
538 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock ? KeyCode::numberPadSix : KeyCode::rightArrow);
539 break;
540
542 case KeyCodeEN_US::leftShift:
543 this->m_keyboard_state.left_shift = !this->m_keyboard_state.left_shift;
544 on_key_read(released, this->m_keyboard_state, KeyCode::leftShift);
545 break;
546
547 case KeyCodeEN_US::Z:
548 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::Z : KeyCode::z);
549 break;
550
551 case KeyCodeEN_US::X:
552 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::X : KeyCode::x);
553 break;
554
555 case KeyCodeEN_US::C:
556 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::C : KeyCode::c);
557 break;
558
559 case KeyCodeEN_US::V:
560 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::V : KeyCode::v);
561 break;
562
563 case KeyCodeEN_US::B:
564 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::B : KeyCode::b);
565 break;
566
567 case KeyCodeEN_US::N:
568 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::N : KeyCode::n);
569 break;
570
571 case KeyCodeEN_US::M:
572 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::M : KeyCode::m);
573 break;
574
575 case KeyCodeEN_US::comma:
576 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::lessThan : KeyCode::comma);
577 break;
578
579 case KeyCodeEN_US::fullStop:
580 on_key_read(released, this->m_keyboard_state, should_be_upper_case ? KeyCode::greaterThan : KeyCode::fullStop);
581 break;
582
583 // Forward slash is same as number pad forward slash
584
585 case KeyCodeEN_US::rightShift:
586 // Check if this is a repeat
587 if (!released) {
588 this->m_keyboard_state.right_shift = !this->m_keyboard_state.right_shift;
589 }
590
591 on_key_read(released, this->m_keyboard_state, KeyCode::rightShift);
592 break;
593
594 // Up Arrow is the same as number pad 8
595
596 // Number pad 1 is the same as end
597
598 case KeyCodeEN_US::numberPadTwo:
599 on_key_read(released, this->m_keyboard_state, this->m_keyboard_state.number_pad_lock ? KeyCode::numberPadTwo : KeyCode::downArrow);
600 break;
601
602 // Number pad 3 is the same as page down
603
604 // Number pad enter is the same as enter
605
607 case KeyCodeEN_US::leftControl:
608 // Check if this is a repeat
609 if (!released) {
610 this->m_keyboard_state.left_control = !this->m_keyboard_state.left_control;
611 this->m_keyboard_state.right_control = !this->m_keyboard_state.right_control;
612 }
613
614 on_key_read(released, this->m_keyboard_state, KeyCode::leftControl);
615 break;
616
617 case KeyCodeEN_US::leftOS:
618 on_key_read(released, this->m_keyboard_state, KeyCode::leftOS);
619 break;
620
621 case KeyCodeEN_US::leftAlt:
622 // Check if this is a repeat
623 if (!released) {
624 this->m_keyboard_state.left_alt = !this->m_keyboard_state.left_alt;
625 this->m_keyboard_state.right_alt = !this->m_keyboard_state.right_alt;
626 }
627
628 on_key_read(released, this->m_keyboard_state, KeyCode::leftAlt);
629 break;
630
631 case KeyCodeEN_US::space:
632 on_key_read(released, this->m_keyboard_state, KeyCode::space);
633 break;
634
635 // Right Alt is the same as left alt
636
637 // Right Control is the same as left control
638
639 // Left Arrow is the same as number pad 4
640
641 // Down Arrow is the same as number pad 2
642
643 // Right Arrow is the same as number pad 6
644
645 // Number pad 0 is the same as insert
646
647 // Number pad full stop is the same as delete
648
649 default:
650 break;
651
652 }
653
654}
MaxOS::common::Rectangle
Stores the left, top, width and height of a rectangle.
Definition rectangle.h:22
MaxOS::drivers::peripherals::KeyboardInterpreterEN_US::KeyCodeEN_US
KeyCodeEN_US
The scan codes for the EN_US keyboard layout.
Definition keyboard.h:318
MaxOS::drivers::peripherals::KeyboardInterpreter::m_next_is_first_extended_code
bool m_next_is_first_extended_code
If true, the next code should be interpreted as an extended code (set when receiving 0xE0)
Definition keyboard.h:294
MaxOS::drivers::peripherals::KeyboardInterpreter::on_key_read
void on_key_read(bool, const KeyboardState &, KeyCode)
Handle the key event.
Definition keyboard.cpp:143
MaxOS::drivers::peripherals::KeyboardInterpreter::m_extended_scan_code_bytes
uint8_t m_extended_scan_code_bytes
How many bytes are left to read for the current extended scan code.
Definition keyboard.h:295
MaxOS::drivers::peripherals::KeyboardInterpreter::m_extended_code_buffer
uint16_t m_extended_code_buffer
The storage for scan codes that take more than one byte.
Definition keyboard.h:296
MaxOS::drivers::peripherals::KeyboardInterpreter::m_keyboard_state
KeyboardState m_keyboard_state
The current state of what special keys are pressed on the keyboard.
Definition keyboard.h:292
MaxOS::drivers::peripherals::KeyboardState::left_control
bool left_control
Is the left control key pressed.
Definition keyboard.h:224
MaxOS::drivers::peripherals::KeyboardState::left_shift
bool left_shift
Is the left shift key pressed.
Definition keyboard.h:222
MaxOS::drivers::peripherals::KeyboardState::right_control
bool right_control
Is the right control key pressed.
Definition keyboard.h:225
MaxOS::drivers::peripherals::KeyboardState::number_pad_lock
bool number_pad_lock
Is number pad lock enabled.
Definition keyboard.h:231
MaxOS::drivers::peripherals::KeyboardState::caps_lock
bool caps_lock
Is caps lock enabled.
Definition keyboard.h:230
MaxOS::drivers::peripherals::KeyboardState::right_alt
bool right_alt
Is the right alt key pressed.
Definition keyboard.h:227
MaxOS::drivers::peripherals::KeyboardState::left_alt
bool left_alt
Is the left alt key pressed.
Definition keyboard.h:226
MaxOS::drivers::peripherals::KeyboardState::right_shift
bool right_shift
Is the right shift key pressed.
Definition keyboard.h:223
MaxOS::drivers::peripherals::ScanCodeType
ScanCodeType
The type of scan code being sent by the keyboard.
Definition keyboard.h:30
MaxOS::drivers::peripherals::KeyCode
KeyCode
A mapping of key codes to their values.
Definition keyboard.h:40

References MaxOS::drivers::peripherals::KeyboardState::caps_lock, MaxOS::drivers::peripherals::KeyboardState::left_alt, MaxOS::drivers::peripherals::KeyboardState::left_control, MaxOS::drivers::peripherals::KeyboardState::left_shift, MaxOS::drivers::peripherals::KeyboardInterpreter::m_extended_code_buffer, MaxOS::drivers::peripherals::KeyboardInterpreter::m_extended_scan_code_bytes, MaxOS::drivers::peripherals::KeyboardInterpreter::m_keyboard_state, MaxOS::drivers::peripherals::KeyboardInterpreter::m_next_is_first_extended_code, MaxOS::drivers::peripherals::KeyboardState::number_pad_lock, MaxOS::drivers::peripherals::KeyboardInterpreter::on_key_read(), MaxOS::drivers::peripherals::KeyboardState::right_alt, MaxOS::drivers::peripherals::KeyboardState::right_control, and MaxOS::drivers::peripherals::KeyboardState::right_shift.

The documentation for this class was generated from the following files: