/*
* Supply raw keystrokes when keyboard is open in firm event mode.
*
* Turn the keystroke into an event and put it in the queue.
* If the queue is full, the keystroke is lost (sorry!).
*/
static void
kbd_input_event(struct kbd_softc *k, int code)
{
struct firm_event *fe;
int put;
#ifdef DIAGNOSTIC
if (!k->k_evmode) {
printf("%s: kbd_input_event called when not in event mode\n",
device_xname(k->k_dev));
return;
}
#endif
put = k->k_events.ev_put;
fe = &k->k_events.ev_q[put];
put = (put + 1) % EV_QSIZE;
if (put == k->k_events.ev_get) {
log(LOG_WARNING, "%s: event queue overflow\n",
device_xname(k->k_dev));
return;
}
fe->id = KEY_CODE(code);
fe->value = KEY_UP(code) ? VKEY_UP : VKEY_DOWN;
getmicrotime(&fe->time);
k->k_events.ev_put = put;
EV_WAKEUP(&k->k_events);
}
const TEXTCHAR* GetKeyText (int key)
{
int used = 0;
CTEXTSTR result = SACK_Vidlib_GetKeyText( IsKeyPressed( key ), KEY_CODE( key ), &used );
if( used )
return result;
return 0;
}
/*
* Turn keyboard up/down codes into a KEYSYM.
* Note that the "kd" driver (on sun3 and sparc64) uses this too!
*/
int
kbd_code_to_keysym(struct kbd_state *ks, int c)
{
u_short *km;
int keysym;
/*
* Get keymap pointer. One of these:
* release, control, shifted, normal, ...
*/
if (KEY_UP(c))
km = ks->kbd_k.k_release;
else if (ks->kbd_modbits & KBMOD_CTRL_MASK)
km = ks->kbd_k.k_control;
else if (ks->kbd_modbits & KBMOD_SHIFT_MASK)
km = ks->kbd_k.k_shifted;
else
km = ks->kbd_k.k_normal;
if (km == NULL) {
/*
* Do not know how to translate yet.
* We will find out when a RESET comes along.
*/
return KEYSYM_NOP;
}
keysym = km[KEY_CODE(c)];
/*
* Post-processing for Caps-lock
*/
if ((ks->kbd_modbits & (1 << KBMOD_CAPSLOCK)) &&
(KEYSYM_CLASS(keysym) == KEYSYM_ASCII) )
{
if (('a' <= keysym) && (keysym <= 'z'))
keysym -= ('a' - 'A');
}
/*
* Post-processing for Num-lock. All "function"
* keysyms get indirected through another table.
* (XXX: Only if numlock on. Want off also!)
*/
if ((ks->kbd_modbits & (1 << KBMOD_NUMLOCK)) &&
(KEYSYM_CLASS(keysym) == KEYSYM_FUNC) )
{
keysym = kbd_numlock_map[keysym & 0x3F];
}
return keysym;
}
static int OnKeyCommon( BANNER_NAME )( PSI_CONTROL pc, uint32_t key )
{
PBANNER *ppBanner = (PBANNER*)GetCommonUserData( pc );
PBANNER banner;
// actually let's just pretend we don't handle any key....
int handled = 0;
if( !ppBanner || !(*ppBanner ) )
return 0; // no cllick, already closed.
#ifdef DEBUG_BANNER_DRAW_UPDATE
lprintf( WIDE( "..." ) );
#endif
if( IsKeyPressed( key ) )
{
banner = (*ppBanner);
if( banner )
{
if( KEY_CODE( key ) == KEY_ENTER )
{
#ifdef DEBUG_BANNER_DRAW_UPDATE
lprintf( WIDE( "enter.." ) );
#endif
if( ( banner->flags & BANNER_OPTION_OKAYCANCEL )
&& ( banner->flags & BANNER_OPTION_YESNO ) )
{
}
else if( ( banner->flags & BANNER_OPTION_OKAYCANCEL )
|| ( banner->flags & BANNER_OPTION_YESNO ) )
banner->flags |= BANNER_OKAY;
}
if( !(banner->flags & BANNER_DEAD )
&& ( banner->flags & BANNER_CLICK ) )
{
banner->flags |= (BANNER_CLOSED);
{
PTHREAD thread = banner->pWaitThread;
if( thread )
{
WakeThread( thread );
}
}
// test for obutton too so any keypress also clearsit.
//RemoveBannerEx( ppBanner DBG_SRC );
}
}
}
return handled;
}
static void
kbd_input_wskbd(struct kbd_softc *k, int code)
{
int type, key;
#ifdef WSDISPLAY_COMPAT_RAWKBD
if (k->k_wsraw) {
u_char buf;
buf = code;
wskbd_rawinput(k->k_wskbd, &buf, 1);
return;
}
#endif
type = KEY_UP(code) ? WSCONS_EVENT_KEY_UP : WSCONS_EVENT_KEY_DOWN;
key = KEY_CODE(code);
wskbd_input(k->k_wskbd, type, key);
}
int
kbdintr(void *arg)
{
u_char c, st;
struct kbd_softc *sc = arg;
struct firm_event *fe;
int put;
/* clear receiver error if any */
st = mfp_get_rsr();
c = mfp_get_udr();
if ((st & MFP_RSR_BF) == 0)
return 0; /* intr caused by an err -- no char received */
/* if not in event mode, deliver straight to ite to process key stroke */
if (!sc->sc_event_mode) {
kbdbuf[kbdputoff++ & KBDBUFMASK] = c;
softint_schedule(sc->sc_softintr_cookie);
return 0;
}
/* Keyboard is generating events. Turn this keystroke into an
event and put it in the queue. If the queue is full, the
keystroke is lost (sorry!). */
put = sc->sc_events.ev_put;
fe = &sc->sc_events.ev_q[put];
put = (put + 1) % EV_QSIZE;
if (put == sc->sc_events.ev_get) {
log(LOG_WARNING, "keyboard event queue overflow\n"); /* ??? */
return 0;
}
fe->id = KEY_CODE(c);
fe->value = KEY_UP(c) ? VKEY_UP : VKEY_DOWN;
firm_gettime(fe);
sc->sc_events.ev_put = put;
softint_schedule(sc->sc_softintr_cookie);
return 0;
}
