Return to keyboard.3r CVS log

Up to [Research Unix] / researchv10dc / 630 / man / src / p_man / man3

Annotation of researchv10dc/630/man/src/p_man/man3/keyboard.3r, revision 1.1

1.1     ! root        1: .ds ZZ DEVELOPMENT PACKAGE
        !             2: .TH KEYBOARD 3R "630 MTG"
        !             3: .XE "keyboard"
        !             4: .XE "NOPFEXPAND"
        !             5: .XE "NOCURSEXPAND"
        !             6: .XE "NOPADEXPAND"
        !             7: .XE "NOTRANSLATE"
        !             8: .XE "reqkbdID()"
        !             9: .SH NAME
        !            10: keyboard: P->state, SCRLOCKREQD, SCR_LOCK, NOPFEXPAND, NOCURSEXPAND, NOPADEXPAND, NOTRANSLATE, reqkbdID( ) \- per process keyboard states, keyboard ID
        !            11: 
        !            12: .SH SYNOPSIS
        !            13: .B #include <dmd.h>
        !            14: .sp
        !            15: .B long P->state;
        !            16: .sp
        !            17: .B void reqkbdID ( )
        !            18: 
        !            19: .SH DESCRIPTION
        !            20: .I P->state
        !            21: is the state variable for an application running in the 630
        !            22: MTG.
        !            23: .PP
        !            24: An application can give different interpretations on 
        !            25: groups of 630 MTG supported keyboard keys by
        !            26: setting corresponding bits in the process state variable.
        !            27: The groups are Scroll Lock key, programmable function keys, arrow keys,
        !            28: numerical keypad keys, or the whole keyboard. If
        !            29: the bits are not set, when a key is depressed, the
        !            30: keyboard will send to the process the ASCII/hexadecimal code(s) as specified 
        !            31: by the \fI630 MTG Terminal User's Guide\fR.
        !            32: An exception is the Scroll Lock key
        !            33: which is a "dead" key (no special processing) if it is not requested
        !            34: and processed by the application itself.
        !            35: .PP
        !            36: If an application program wishes to implement local 
        !            37: terminal flow control with the
        !            38: keyboard Scroll Lock key, it must request the use of the Scroll Lock key
        !            39: by setting the \s-1SCRLOCKREQD\s+1 in the state variable as follows:
        !            40: .sp
        !            41: .ft CM
        !            42: .ce
        !            43: P->state |= SCRLOCKREQD;
        !            44: .ft R
        !            45: .PP
        !            46: The application program can then determine if the Scroll Lock key has been
        !            47: depressed by checking the SCR_LOCK bit as follows:
        !            48: .sp
        !            49: .ft CM
        !            50: .ce
        !            51: P->state & SCR_LOCK;
        !            52: .ft R
        !            53: .PP
        !            54: The SCR_LOCK bit is set whenever the Scroll Lock key is depressed. It is 
        !            55: automatically cleared by the keyboard when the Scroll Lock key is depressed a second time.
        !            56: .PP
        !            57: The programmable function (PF) keys, 
        !            58: when depressed are expanded by default,
        !            59: i.e., the corresponding character strings (minus the \s-1NULL\s+1 character)
        !            60: stored in the non-volatile BRAM memory will be sent to the process as would
        !            61: be typed from the keyboard. If an application prefers to have its own interpretation
        !            62: of the programmable function keys,
        !            63: it is necessary to set a bit in the process state variable:
        !            64: .sp
        !            65: .nf
        !            66: .ft CM
        !            67: .ce
        !            68: P->state |= NOPFEXPAND;
        !            69: .ft R
        !            70: .fi
        !            71: .sp
        !            72: In this case, the keyboard will only send to the process the PF key keycode
        !            73: which is 0x80 for PF key F1, 0x81 for PF key F2, and so forth.
        !            74: .PP
        !            75: 
        !            76: If a program wants to interpret the arrow keys without having to parse
        !            77: their entire sequence, it can set a bit in the process state variable:
        !            78: .sp
        !            79: .nf
        !            80: .ft CM
        !            81: .ce
        !            82: P->state |= NOCURSEXPAND;
        !            83: .ft R
        !            84: .fi
        !            85: .sp
        !            86: When an arrow key is then depressed, it will have the value:
        !            87: .sp
        !            88: .DS
        !            89: .TS
        !            90: center, tab(~);
        !            91: lp10 lp10.
        !            92: up arrow~0xE0
        !            93: down arrow~0xE1
        !            94: right arrow~0xE2
        !            95: left arrow~0xE3
        !            96: home key~0xE4
        !            97: .TE
        !            98: .DE
        !            99: .PP
        !           100: If a program wants to have its own interpretation of the numerical
        !           101: keypad keys,
        !           102: it is necessary to set a bit in the process state variable:
        !           103: .sp
        !           104: .ft CM
        !           105: .ce
        !           106: P->state |= NOPADEXPAND;
        !           107: .ft R
        !           108: .sp
        !           109: When a numerical keypad key is then depressed, it will have the value:
        !           110: .sp
        !           111: .DS
        !           112: .TS
        !           113: center, tab(~);
        !           114: lp10 lp10.
        !           115: Enter~0xC0
        !           116: \\=~0xC1
        !           117: *~0xC2
        !           118: /~0xC3
        !           119: +~0xC4
        !           120: 7~0xC5
        !           121: 8~0xC6
        !           122: 9~0xC7
        !           123: -~0xC8
        !           124: 4~0xC9
        !           125: 5~0xCA
        !           126: 6~0xCB
        !           127: ,~0xCC
        !           128: 1~0xCD
        !           129: 2~0xCE
        !           130: 3~0xCF
        !           131: 0~0xD0
        !           132: \\\.~0xD1
        !           133: .TE
        !           134: .DE
        !           135: .PP
        !           136: If a program wants to remap the entire keyboard, it must
        !           137: set a bit in the state variable:
        !           138: .sp
        !           139: .ft CM
        !           140: .ce
        !           141: P->state |= NOTRANSLATE;
        !           142: .ft R
        !           143: .sp
        !           144: The application will then receive from the keyboard the raw keycodes 
        !           145: as listed in the \fI630 MTG Terminal User's Guide\fR. 
        !           146: Also, the keyboard LEDs will no longer be automatically updated.
        !           147: At this point, calling the
        !           148: .I reqkbdID
        !           149: function will ask the keyboard for its identity (ID).
        !           150: The keyboard will send back its ID and all keys currently depressed,
        !           151: followed again by the ID. Refer to the \f2630 MTG
        !           152: Software Development Guide\f1 for more information.
        !           153: 
        !           154: .SH SEE ALSO
        !           155: kbdchar(3R), state(3R), pfkey(3R), resources(3R), setled(3L).
        !           156: .br
        !           157: \fI630 MTG Terminal User's Guide\fR.
        !           158: .br
        !           159: \f2630 MTG Software Development Guide\f1.
        !           160: .SH WARNING
        !           161: If the process has not requested the keyboard (see \fIresources(3r)\fR),
        !           162: all per process keyboard states will be ignored, and the key's
        !           163: ASCII/hexadecimal code(s) as specified in the
        !           164: \fI630 MTG Terminal User's Guide\fR will be
        !           165: sent to the host (if the process is connected) or ignored (if the process
        !           166: runs locally).
        !           167: .PP
        !           168: The exception is the Scroll Lock key which does not require the application
        !           169: to request the whole keyboard. However in order to process that key, the
        !           170: application has to set the SCRLOCKREQD bit in \fIP->state\fR.

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.