def process_key(holded):
if self.special_char_request:
self.removePopup()
self.special_char_request = False
#if 'ctrl' in holded and key == events.SPACEKEY:
if key in self.special_char_map:
self.curInsertChar(self.special_char_map[key])
elif 'ctrl' in holded and key == events.SPACEKEY:
self.removePopup()
self.AddScrollback('╔' + '═' * 78 + '╗', MESSGS_COLOR)
self.AddScrollback(
'║ 1 () 2 [] 3 {} 4 <>'
' 5 \\\' 6 @& 7 ;: '
' 8 +* 9 -/ ║', MESSGS_COLOR)
self.AddScrollback('╚' + '═' * 78 + '╝', MESSGS_COLOR)
self.special_char_request = True
self.doing_autocomplete = False
self.popup_lines += 3
else:
self.curInsertChar(
events.EventToCharacter(key, 'shft' in holded).translate(
self.my_keyboard))
if self.doing_autocomplete:
self.autocomp()
def update(self):
for w in self.widgets:
if w.parent is None:
w.update()
## Mouse button event
mouse_button_events = [
events.LEFTMOUSE, events.MIDDLEMOUSE, events.RIGHTMOUSE
]
## Modifiers
mods = []
for ev in [
events.LEFTSHIFTKEY, events.RIGHTSHIFTKEY, events.LEFTALTKEY,
events.RIGHTALTKEY, events.LEFTCTRLKEY, events.RIGHTCTRLKEY
]:
if logic.keyboard.inputs[ev].active:
mods.append(ev)
mx, my, on_screen = self.output.get_mouse_position()
mbe = MouseButtonEvent(0, 0, mx, my)
for e in mouse_button_events:
mbe.modifiers = mods
mbe.button = e
if logic.mouse.inputs[e].activated and on_screen:
mbe.status = True
self.event_handler.send(mbe)
elif logic.mouse.inputs[e].released and on_screen:
mbe.status = False
self.event_handler.send(mbe)
## Mouse motion event
if on_screen:
mme = MouseMotionEvent(mx, my, mx - self.px, my - self.py)
self.event_handler.send(mme)
## Mouse wheel events
if on_screen:
delta = 0
if logic.mouse.inputs[events.WHEELUPMOUSE].activated:
delta = 1
elif logic.mouse.inputs[events.WHEELDOWNMOUSE].activated:
delta = -1
if abs(delta) > 0:
self.event_handler.send(ScrollEvent(delta))
self.px = mx
self.py = my
## Key events
for i in range(0, 256):
shift = logic.keyboard.inputs[events.LEFTSHIFTKEY].active or \
logic.keyboard.inputs[events.RIGHTSHIFTKEY].active
try:
# Text Event
if logic.keyboard.inputs[i].activated:
c = events.EventToCharacter(i, shift)
if len(c) > 0:
self.event_handler.send(TextEvent(c))
# Key Event
if logic.keyboard.inputs[i].activated:
self.event_handler.send(KeyEvent(i, mods, True))
self.__keys_down[i] = True
else:
if self.__keys_down[i] == True:
self.event_handler.send(KeyEvent(i, mods, False))
self.__keys_down[i] = False
except KeyError:
continue
def onKeyPress(self, data):
if self.readOnly: return
key, shift = data["key"], data["shift"]
chr = events.EventToCharacter(key, shift)
self.blink = True
ln = self.text
if self.numbersOnly:
if key not in [
events.ONEKEY, events.TWOKEY, events.THREEKEY,
events.FOURKEY, events.FIVEKEY, events.SIXKEY,
events.SEVENKEY, events.EIGHTKEY, events.NINEKEY,
events.ZEROKEY, events.PAD0, events.PAD1, events.PAD2,
events.PAD3, events.PAD4, events.PAD5, events.PAD6,
events.PAD7, events.PAD8, events.PAD9, events.PADPERIOD,
events.PADMINUS, events.PERIODKEY, events.MINUSKEY,
events.LEFTARROWKEY, events.RIGHTARROWKEY,
events.BACKSPACEKEY, events.DELKEY
]:
return
if key == events.LEFTARROWKEY:
if self.caretx > 0:
self.caretx -= 1
else:
self.caretx = 0
elif key == events.RIGHTARROWKEY:
if self.caretx < len(ln):
self.caretx += 1
else:
self.caretx = len(ln)
elif key == events.TABKEY:
ln = ln[:self.caretx] + " " + ln[self.caretx:]
self.text = ln
self.caretx += 4
elif key == events.BACKSPACEKEY:
if self.caretx > 0:
if self.caretx < len(self.text):
self.caretx -= 1
ln = ln[:self.caretx] + ln[self.caretx + 1:]
else:
ln = ln[:self.caretx - 1] + ln[self.caretx:]
self.text = ln
else:
self.caretx = 0
elif key == events.DELKEY:
stln = ln[self.caretx:]
if len(stln) > 0:
ln = ln[:self.caretx] + ln[self.caretx + 1:]
self.text = ln
elif key == events.LEFTSHIFTKEY or key == events.RIGHTSHIFTKEY:
pass
else:
if self.caretx >= len(ln):
ln += chr
else:
ln = ln[:self.caretx] + chr + ln[self.caretx:]
self.caretx += 1
ln = ln.replace("\n", "")
self.text = ln
fire_if_possible(self.on_text_changed, self, ln)
self.text = ln
self.__update_cx()
from bge import logic as G
from bge import events as GK
cont = G.getCurrentController()
owner = cont.owner
sensor = cont.sensors["s_keyboard"]
if sensor.positive:
keylist = sensor.events
# get only the first pressed key
event = keylist[0]
pressed_key = event[0]
status = event[1]
text = "the key number is: %d\n" % pressed_key
text += "the key value is: %s\n" % GK.EventToString(pressed_key)
text += "the character is: %s\n" % GK.EventToCharacter(
pressed_key, 0) # (key_code, captalize_flag)
# optionally you can see the key status too if you want (just activated,
# text += "the status is: %d\n" % status
# press space to reset the initial text
if pressed_key == GK.SPACEKEY:
text = "Please, press any key."
owner["Text"] = text
def event(self):
if self.visible and self.enabled:
bounds = self.transformedBounds()
mx, my = GFX_mousePosition()
if bounds.hasPoint(mx, my):
if self.state == COMP_STATE_NORMAL:
self.state = COMP_STATE_HOVER
self.events.call(EV_MOUSE_ENTER, self)
else:
if self.state == COMP_STATE_HOVER:
self.state = COMP_STATE_NORMAL
self.events.call(EV_MOUSE_LEAVE, self)
if GFX_mouseClick(events.LEFTMOUSE):
if self.state == COMP_STATE_HOVER:
self.state = COMP_STATE_CLICK
self.__blink = True
self.__t.reset()
self.events.call(EV_MOUSE_CLICK, self)
elif self.state == COMP_STATE_CLICK and not bounds.hasPoint(
mx, my):
self.state = COMP_STATE_NORMAL
self.events.call(EV_MOUSE_RELEASE, self)
if self.__x > len(self.text):
self.__x = len(self.text)
if self.state == COMP_STATE_CLICK and not self.readOnly:
shift = GFX_keyDown(events.LEFTSHIFTKEY) or \
GFX_keyDown(events.RIGHTSHIFTKEY)
if GFX_keyPressed(events.LEFTARROWKEY):
if self.__x > 0:
self.__x -= 1
self.events.call(EV_KEY_PRESS, self, events.LEFTARROWKEY)
self.__blink = True
elif GFX_keyPressed(events.RIGHTARROWKEY):
if self.__x < len(self.text):
self.__x += 1
self.events.call(EV_KEY_PRESS, self, events.RIGHTARROWKEY)
self.__blink = True
elif GFX_keyPressed(events.BACKSPACEKEY):
if self.__x > 0:
self.__x -= 1
s = self.text
self.text = s[:self.__x] + s[self.__x + 1:]
self.events.call(EV_KEY_PRESS, self, events.BACKSPACEKEY)
self.__blink = True
elif GFX_keyPressed(events.DELKEY):
if len(self.text[self.__x:]) != 0:
s = self.text
self.text = s[:self.__x] + s[self.__x + 1:]
self.events.call(EV_KEY_PRESS, self, events.DELKEY)
self.__blink = True
else:
for k, v in list(GFX_SupportedKeys.items()):
if GFX_keyPressed(v):
key = events.EventToCharacter(v, shift)
s = self.text
self.text = s[:self.__x] + key + s[self.__x:]
self.__x += 1
self.__blink = True
self.events.call(EV_KEY_PRESS, self, v)
break
# #############################
import bge
from bge import logic
from bge import events
cont = logic.getCurrentController()
owner = cont.owner
sensor = cont.sensors["s_keyboard"]
active_events = logic.keyboard.active_events
if len(active_events):
text = ""
# get only the first pressed key
for key,status in active_events.items():
text += "the key number is: %d\n" % key
text += "the key value is: %s\n" % events.EventToString(key)
text += "the character is: %s\n" % events.EventToCharacter(key, 0) # (key_code, captalize_flag)
# optionally you can see the key status too if you want (just activated,
text += "the status is: %d\n" % status
# press space to reset the initial text
if key == events.SPACEKEY:
text = "Please, press any key."
break
owner["Text"] = text