def Active(self):
selected = True
# highlight current widget to show it is active
self.Highlight()
while selected:
key = self.Win.getch()
# capture ENTER, TAB, and BACKTAB keystrokes
if key in [curses.KEY_ENTER, ord('\n'), 10]:
self.UnHighlight()
selected = False
self.CallMethod()
elif key in [ord('\t'), 9] and not self.DisableTab:
# stop highlighting current widget
self.UnHighlight()
selected = False
curses.ungetch(key) # pass tab along so Screen will know to go to next widget
# go to menu (SHIFT-M or F1)
# or go to status screen (SHIFT-M or F8)
elif key in [curses.KEY_F1, 77, curses.KEY_F8, 76] and not self.DisableScreenSwitch:
selected = False
curses.ungetch(key)
def read_key(self, flush_first=False):
if flush_first:
self.flush_input()
key = self._window.getch()
if key == curses.KEY_MOUSE:
try:
mouse = curses.getmouse()
if mouse[4] & curses.BUTTON1_RELEASED:
key = "MOUSE_1RELEASED"
elif (mouse[4] & curses.BUTTON2_RELEASED |
mouse[4] & curses.BUTTON2_CLICKED |
mouse[4] & curses.BUTTON2_DOUBLE_CLICKED |
mouse[4] & curses.BUTTON2_TRIPLE_CLICKED |
mouse[4] & curses.BUTTON2_PRESSED):
key = "MOUSE_SCROLL_DOWN"
elif mouse[4] & curses.BUTTON3_RELEASED:
key = "MOUSE_3RELEASED"
elif (mouse[4] & curses.BUTTON4_RELEASED |
mouse[4] & curses.BUTTON4_CLICKED |
mouse[4] & curses.BUTTON4_DOUBLE_CLICKED |
mouse[4] & curses.BUTTON4_TRIPLE_CLICKED |
mouse[4] & curses.BUTTON4_PRESSED):
key = "MOUSE_SCROLL_UP"
else: key = "MOUSE_UNKNOWN"
self.mouse_location = (mouse[1], mouse[2])
except:
key = "MOUSE_UNKNOWN"
else:
curses.ungetch(key)
key = self._window.getkey()
if key == "KEY_RESIZE": return "WINDOW_RESIZED"
return key
def _inject_key(screen, char):
"""
Inject a specified character into the input buffers.
"""
if sys.platform == "win32":
event = win32console.PyINPUT_RECORDType(win32console.KEY_EVENT)
event.RepeatCount = 1
event.ControlKeyState = 0
event.VirtualScanCode = 0
if char >= 0:
event.Char = chr(char)
event.VirtualKeyCode = ord(chr(char).upper())
else:
# Lookup in mapping dicts
reverse = dict(
(v, k) for k, v in screen._EXTRA_KEY_MAP.items())
if char in reverse:
event.VirtualKeyCode = reverse[char]
else:
# Fudge key state required for BACK_TAB if needed.
if char == Screen.KEY_BACK_TAB:
char = Screen.KEY_TAB
event.ControlKeyState = win32con.SHIFT_PRESSED
reverse = dict((v, k) for k, v in screen._KEY_MAP.items())
event.VirtualKeyCode = reverse[char]
event.KeyDown = 1
screen._stdin.WriteConsoleInput([event])
event.KeyDown = 0
screen._stdin.WriteConsoleInput([event])
else:
curses.ungetch(char)
def kbhit(self):
ch = self.win.getch()
if (ch != -1):
curses.ungetch(ch)
return 1
else:
return 0
def CaptureText(self):
# Special keys handled by CaptureText()
# ESC: exits without capturing anything, current widget still highlighted
# ENTER: exits with capturing all previously entered text, current widget still highlighted
# TAB: exits with capturing and moves to next widget
# BACKSPACE: removes last character from self.Text
capturing = True
old_text = self.Text
self.UnHighlight()
while capturing:
self.Win.move(0, min(len(self.Text), self.Characters - 1))
key = self.Win.getch()
# in case no delay mode is set to true
if key == -1:
pass
# ESC
# 27 can mean either ALT or ESC in ncurses
# following code from http://stackoverflow.com/questions/5977395/ncurses-and-esc-alt-keys
# used to resolve ESC vs ALT+key with key input
if key == 27:
self.Win.nodelay(True)
n = self.Win.getch()
if n == -1:
# ESC was pressed and not ALT
self.Text = old_text
self.DisplayMode = "STANDARD"
self.Highlight()
capturing = False
self.Win.nodelay(False)
# ENTER
elif key in [curses.KEY_ENTER, ord('\n'), 10]:
self.DisplayMode = "STANDARD"
self.Highlight()
capturing = False
# TAB
elif key in [ord('\t'), 9]:
self.DisplayMode = "STANDARD"
self.UnHighlight()
capturing = False
curses.ungetch('\t') # Notify the core that tab was pressed
# -- Added 8 and 127, additional possible backspace inputs (127 on my system)
# http://stackoverflow.com/questions/4363309/how-to-check-for-the-backspace-character-in-c
elif key in [curses.KEY_BACKSPACE, ord('\b'), 10, 8, 127]:
# erase last character entered
self.Text = self.Text[:-1]
self.DisplayMode = "TYPING"
else:
self.Text += chr(key)
self.DisplayMode = "TYPING"
self.UpdateDisplay()
def SetNextScreen(self):
# if connection is set or user is going to ConnectionWizard screen
if not CDBCore.CDBCore.Connection and self.CurrentWidget > 0:
msg = "Error: No Connection Detected.\nSelect Connection Wizard to connect to a\ndatabase."
CDBCore.CDBCore.StatusScreen.AddStatusMessage(msg)
CDBCore.CDBCore.PopUp = PopUpOk(msg)
CDBCore.CDBCore.PopUp.MakeActive()
# if a connection is established but a database is not set
elif CDBCore.CDBCore.Connection and not CDBCore.CDBCore.Connection.Database and (self.CurrentWidget == 2 or self.CurrentWidget == 3 or self.CurrentWidget == 5):
msg = "Error: No Database Detected.\nSelect or Create a Database first."
CDBCore.CDBCore.StatusScreen.AddStatusMessage(msg)
CDBCore.CDBCore.PopUp = PopUpOk(msg)
CDBCore.CDBCore.PopUp.MakeActive()
elif CDBCore.CDBCore.Connection and CDBCore.CDBCore.Connection.DBType == "PostgreSQL" and self.CurrentWidget == 1:
msg = "Select Database unavailable for PostgreSQL\nserver.\n\nPlease Use a New Connection to access a\ndifferent database."
CDBCore.CDBCore.StatusScreen.AddStatusMessage(msg)
CDBCore.CDBCore.PopUp = PopUpOk(msg)
CDBCore.CDBCore.PopUp.MakeActive()
elif CDBCore.CDBCore.Connection and CDBCore.CDBCore.Connection.DBType == "PostgreSQL" and self.CurrentWidget == 4:
msg = "Error: Cannot create databases when using\nPostgreSQL connector.\n\nUse PSQL tool."
CDBCore.CDBCore.StatusScreen.AddStatusMessage(msg)
CDBCore.CDBCore.PopUp = PopUpOk(msg)
CDBCore.CDBCore.PopUp.MakeActive()
else:
self.NextScreen = self.Screens[self.CurrentWidget]
curses.ungetch('\n')
def _inject_key(screen, char):
"""
Inject a specified character into the input buffers.
"""
if sys.platform == "win32":
event = win32console.PyINPUT_RECORDType(win32console.KEY_EVENT)
event.RepeatCount = 1
event.ControlKeyState = 0
event.VirtualScanCode = 0
if char >= 0:
event.Char = chr(char)
event.VirtualKeyCode = ord(chr(char).upper())
else:
# Lookup in mapping dicts
reverse = dict((v, k) for k, v in
screen._EXTRA_KEY_MAP.items())
if char in reverse:
event.VirtualKeyCode = reverse[char]
else:
# Fudge key state required for BACK_TAB if needed.
if char == Screen.KEY_BACK_TAB:
char = Screen.KEY_TAB
event.ControlKeyState = win32con.SHIFT_PRESSED
reverse = dict((v, k) for k, v in
screen._KEY_MAP.items())
event.VirtualKeyCode = reverse[char]
event.KeyDown = 1
screen._stdin.WriteConsoleInput([event])
event.KeyDown = 0
screen._stdin.WriteConsoleInput([event])
else:
curses.ungetch(char)
def test_menu_item_textentryitem(self):
"""Test that TextEntryItem obtains user input when called and that get_value() returns the stored value."""
curses.initscr()
curses.ungetch("\n")
curses.ungetch("a")
self.textentryitem()
self.assertEqual(self.textentryitem.get_value(), "a")
def editCurrentTextbox(self):
curses.curs_set(1)
curses.ungetch(0)
self.fieldValues[self.currentField()] = self.currentTextbox()[0].edit().strip()
if not self.checkCurrentField():
self.fieldValues[self.currentField()] = ""
curses.curs_set(0)
def TestConnection(self):
# Check that either MySQL or Postgre has been checked
if self.ActionWidgets[self.Input["MySQL"]].Value() and self.ActionWidgets[self.Input["PostgreSQL"]].Value():
self.ResetScreen("Check either MySQL or PostgresSQL, not both.")
return
if not self.ActionWidgets[self.Input["MySQL"]].Value() and not self.ActionWidgets[self.Input["PostgreSQL"]].Value():
self.ResetScreen("Must select MySQL or PostgresSQL.")
return
isMySQL = False
if self.ActionWidgets[self.Input["MySQL"]].Value():
isMySQL = True
# Retrieve the database if one has been provided
database = None
if len(self.ActionWidgets[self.Input["Database (Optional)"]].Text) > 0:
database = self.ActionWidgets[self.Input["Database (Optional)"]].Text
# If Postgres, make sure a database has been provided
if not isMySQL and database == None:
self.ResetScreen("Database required for PostgreSQL connection.")
return
# Get the port
port = 0
try:
port = int(self.ActionWidgets[self.Input["Port"]].Text)
except ValueError:
pass
# Create the connection
con = None
if isMySQL:
con = MySQLConnection(self.ActionWidgets[self.Input["User Name"]].Text,
self.ActionWidgets[self.Input["Password"]].Text,
self.ActionWidgets[self.Input["Host"]].Text,
port,
database)
else:
con = PostgresConnection(self.ActionWidgets[self.Input["User Name"]].Text,
self.ActionWidgets[self.Input["Password"]].Text,
database,
self.ActionWidgets[self.Input["Host"]].Text,
port)
# Attempt to connect with the given information
CDBCore.CDBCore.StatusScreen.AddStatusMessage("Attempting to Connect to Database...")
results = con.Connect()
if results.Success:
CDBCore.CDBCore.Connection = con
CDBCore.CDBCore.StatusScreen.AddStatusMessage("Connection established.")
curses.ungetch('\n') # Notify the core to move to next screen
return
else:
CDBCore.CDBCore.StatusScreen.AddStatusMessage(results.Message)
msg = "Could not connect to database."
self.ResetScreen(msg)
return
def test_menu_unsupportedfooteroption(self):
"""Test that unsupported footer strings raise MenuUnsupportedFooterOptionError when encountered."""
self.menu.footer_items = ["a"]
curses.ungetch("\n")
with self.assertRaises(ec2rlcore.menu.MenuUnsupportedFooterOptionError) as error:
self.assertTrue(self.menu())
self.assertEqual(str(error.exception), "Encountered unsupported footer selection: a")
def wait_input(self, prompt=""):
"""
Wait for the user to input a message and hit enter.
Puts the message into self.inputbuffer
"""
self.inputbuffer = prompt
self.redraw_chatline()
self.boxes['chatline'].cursyncup()
last = -1
while last != ord('\n'):
last = self.stdscr.getch()
if last == ord('\n'):
tmp = self.inputbuffer
self.inputbuffer = ""
self.redraw_chatline()
self.boxes['chatline'].cursyncup()
return tmp[len(prompt):]
elif last == curses.KEY_BACKSPACE or last == 127:
if len(self.inputbuffer) > len(prompt):
self.inputbuffer = self.inputbuffer[:-1]
elif last==curses.KEY_LEFT or last==curses.KEY_UP or last==curses.KEY_DOWN or last==curses.KEY_RIGHT:
self.redraw_ui()
elif last == curses.KEY_RESIZE:
self.resize()
else:
curses.ungetch(last)
self.inputbuffer += self.stdscr.get_wch()
self.redraw_chatline()
def CreateTable(self):
try:
# Construct the create table query from the user's input
query = self.ConstructQuery()
# Attempt to create the table
result = CDBCore.CDBCore.Connection.QueryString(query)
# Ensure that the query was successful
if not result.Success:
raise Exception(result.Message)
# Notify of successful
CDBCore.CDBCore.StatusScreen.AddStatusMessage("Successfully created table: " + self.Name)
# Move on to next screen
curses.ungetch('\n')
except Exception as ex:
# TODO: Add multi-line once status supports it
msg = "Failed to create table:" + self.Name
CDBCore.CDBCore.StatusScreen.AddStatusMessage(msg)
self.ActionWidgets[0].selected = True
self.ActionWidgets[0].Highlight()
self.ActionWidgets[0].Active()
return
def test_menu_config_select_module_exit_selection_no_colors(self, mock_side_effect_function):
"""Test drawing and exiting the menu when the terminal doesn't support colors."""
curses.initscr()
curses.ungetch("\n")
curses.ungetch(curses.KEY_RIGHT)
self.assertTrue(self.menu())
self.assertTrue(mock_side_effect_function.called)
def int16(self):
ah = self.ql.reg.ah
if ah == 0x0:
curses.nonl()
key = self._parse_key(self.stdscr.getch())
self.ql.dprint(0, f"Get key: {hex(key)}")
if curses.ascii.isascii(key):
self.ql.reg.al = key
else:
self.ql.reg.al = 0
self.ql.reg.ah = self._get_scan_code(key)
curses.nl()
elif ah == 0x1:
curses.nonl()
# set non-blocking
self.stdscr.timeout(0)
key = self._parse_key(self.stdscr.getch())
if key == -1:
self.set_flag(0x40)
self.ql.reg.ax = 0
else:
self.ql.dprint(0, f"Has key: {hex(key)} ({curses.ascii.unctrl(key)})")
self.ql.reg.al = key
self.ql.reg.ah = self._get_scan_code(key)
self.clear_flag(0x40)
# Buffer shouldn't be removed in this interrupt.
curses.ungetch(key)
self.stdscr.timeout(-1)
curses.nl()
def input(self):
v = None
l.debug("memcurses input")
c = self._screen.getch()
if c == ord('q'):
l.debug("... quitting")
return False
elif c == ord('X'):
l.debug("... closing %r", self.views[-1])
self.views[-1].close()
self._screen.clear()
elif c == curses.KEY_RESIZE:
l.debug("... window resized")
self._screen.clear()
elif c == curses.KEY_F2:
self._screen.clear()
self.views.append(MemViewDebug(self))
else:
l.debug("... ungetting %r", c)
curses.ungetch(c)
for v in reversed(self.views):
l.debug("Input to %r", v)
r = v.input()
if r is None:
l.debug("... it handled it")
break
elif isinstance(r, MemView):
l.debug("... it created %r", r)
self.views.append(r)
self._screen.clear()
break
return True
def input(self):
v = None
l.debug("memcurses input")
c = self._screen.getch()
if c == ord('q'):
l.debug("... quitting")
return False
elif c == ord('X'):
l.debug("... closing %r", self.views[-1])
self.views[-1].close()
self._screen.clear()
elif c == curses.KEY_RESIZE:
l.debug("... window resized")
self._screen.clear()
elif c == curses.KEY_F2:
self._screen.clear()
self.views.append(MemViewDebug(self))
else:
l.debug("... ungetting %r", c)
curses.ungetch(c)
for v in reversed(self.views):
l.debug("Input to %r", v)
r = v.input()
if r is None:
l.debug("... it handled it")
break
elif isinstance(r, MemView):
l.debug("... it created %r", r)
self.views.append(r)
self._screen.clear()
break
return True
def Active(self):
# Special keys handled by Active()
# ENTER: enters into capture text mode
# TAB: exits with capturing and moves to next widget
self.Highlight()
capturing = True
while capturing:
#self.Win.move(0,0)
key = self.Win.getch()
# ENTER
if key in [curses.KEY_ENTER, ord('\n'), 10]:
self.CaptureText()
# TAB
elif key in [ord('\t'), 9]:
self.UnHighlight()
curses.ungetch('\t') # Notify the core that tab was pressed
capturing = False
# go to menu (SHIFT-M or F1)
# or go to status screen (SHIFT-M or F8)
elif key in [curses.KEY_F1, 77, curses.KEY_F8, 76] and not self.DisableScreenSwitch:
capturing = False
curses.ungetch(key)
def test_menu_textentryitem__ascii_bel(self):
"""Test that the input_caller returns the expected string value."""
curses.initscr()
curses.ungetch("\n")
curses.ungetch(curses.ascii.BEL)
# BEL is a non-printable character so the return value should be an empty string
self.textentryitem()
self.assertEqual(self.textentryitem.get_value(), "")
def _interrupt_handler(signum, frame):
# if a keyboard-interrupt occurs...
if _do_catch_interrupt:
# push a Ctrl+C (ascii value 3) to the curses getch stack
curses.ungetch(3)
else:
# use the default handler
signal.default_int_handler(signum, frame)
def get_key(stdscr): """Workaround for weird Return handling of get_wch() """ key = stdscr.getch() if key == 10: return curses.KEY_ENTER curses.ungetch(key) return stdscr.get_wch()
def end():
self.finished = True
curses.ungetch(27)
self.joinKeyListenerThread()
curses.nocbreak()
self.screen.keypad(False)
curses.echo()
curses.endwin()
def _interrupt_handler(signum, frame):
# if a keyboard-interrupt occurs...
if _do_catch_interrupt:
# push a Ctrl+C (ascii value 3) to the curses getch stack
curses.ungetch(3)
else:
# use the default handler
signal.default_int_handler(signum, frame)
def test_menu_config_key_right_gt_footer_len(self):
"""Test behavior when attempting to select an item to the right of the rightmost footer items."""
curses.initscr()
curses.ungetch("\n")
curses.ungetch(curses.KEY_LEFT)
curses.ungetch(curses.KEY_RIGHT)
curses.ungetch(curses.KEY_RIGHT)
curses.ungetch(curses.KEY_RIGHT)
self.assertTrue(self.menu())
def handlerResize(self, signum="", frame=""):
if self.isInScroll==1:
curses.ungetch("q")
curses.endwin()
self.__init__(1)
curses.ungetch(curses.ascii.NL)
self.printHistory()
self.setTitle(self.channel,self.peersCount)
curses.curs_set(1)
def loot(self, random_loot):
"""
Loot interface
:param random_loot = loot generated in monster class, specific to that mob
:return None
"""
k = -1
start = 10
offset = 15
# random_loot = self.opponent.generate_loot()
# if random_loot:
# loot_list = [helper.get_item(item)() for item in random_loot]
# else:
# loot_list = []
selected_item = 0
height, width = self.screen.getmaxyx()
while k != ord("q"):
self.screen.erase()
start = 10
loot_text = "{} dropped the following loot".format(self.opponent.readable_name)
self.screen.addstr(8, int((width / 2) - (len(loot_text) / 2)), loot_text)
if self.loot_list:
for i in range(len(self.loot_list)):
if selected_item == i:
self.screen.attron(curses.color_pair(5))
self.screen.addstr(start, offset, self.loot_list[i].readable_name)
if selected_item == i:
self.screen.attroff(curses.color_pair(5))
start += 1
else:
self.screen.addstr(start, offset, "No loot")
if k == curses.KEY_DOWN:
if len(self.loot_list) != 0:
selected_item += 1
if selected_item >= len(self.loot_list) - 1:
selected_item = len(self.loot_list) - 1
if k == curses.KEY_UP:
if len(self.loot_list) != 0:
selected_item -= 1
if selected_item <= 0:
selected_item = 0
if k == ord(" "):
if len(self.loot_list) != 0:
self.player.inventory.append(self.loot_list.pop(selected_item))
selected_item = 0
curses.ungetch(curses.KEY_F0)
k = self.screen.getch()
curses.ungetch(curses.KEY_F0)
def kbhit(window):
ch = window.getch()
if (ch != curses.ERR):
curses.ungetch(ch)
if (ch != 'x'):
ch = window.getch()
return 1
else:
return 0
else:
return 0
def kbhit(window):
ch = window.getch();
if (ch != curses.ERR):
curses.ungetch(ch)
if (ch != 'x'):
ch = window.getch();
return 1
else:
return 0
else:
return 0
def Create(self):
try:
name = self.ActionWidgets[0].Text
result = CDBCore.CDBCore.Connection.QueryString("CREATE DATABASE " + name)
if result.Success:
CDBCore.CDBCore.StatusScreen.AddStatusMessage("Successfully created database: "+ name)
curses.ungetch('\n') # Notify the core to move to next screen
else:
raise Exception(result.Message)
except Exception as ex:
msg = "Could not create database: " + name
CDBCore.CDBCore.StatusScreen.AddStatusMessage(msg)
def check_shortcuts(self):
key = self.parent.getch(False)
if key == -1:
return
handler = self.shortcuts.get(key)
# Close all other shortcut handlers
for shortcut in self.shortcuts.values():
if shortcut[1] is not None:
shortcut[1]()
if handler is not None:
handler[0]()
else:
curses.ungetch(key)
def process_ch(self, ch) -> str:
if ch == 27:
# Escape key
return 'Escape'
elif ch == 8:
# Backspace key
return 'Backspace'
elif ch == 10:
# Enter key
return 'Enter'
else:
curses.ungetch(ch)
return None
def DropTblMethod(self):
q = "DROP TABLE {}".format(self.Table)
result = CDBCore.CDBCore.Connection.QueryString(q)
if result.Success:
CDBCore.CDBCore.StatusScreen.AddStatusMessage("Drop Table success")
curses.ungetch('\n')
else:
CDBCore.CDBCore.StatusScreen.AddStatusMessage("Drop Table failed")
self.MakeActive()
def _controller_(self, ch):
"""Control if the character is a control key"""
if ch in [curses.KEY_UP, curses.KEY_DOWN, curses.ascii.TAB,
curses.ascii.CR, curses.ascii.ESC, curses.KEY_MOUSE]:
curses.ungetch(ch)
return curses.ascii.NL
elif ch in [curses.ascii.DEL]:
return curses.ascii.BS
elif curses.ascii.isctrl(ch):
if chr(ch + 64) in self.shortcuts:
curses.ungetch(ch)
return curses.ascii.NL
else:
return ch
def flash(self):
'''Flash this error window'''
if self.visible:
cursor_loc = curses.getsyx()
# flash_color = self.highlight_color ^ curses.A_REVERSE
# self.set_color(flash_color)
curses.setsyx(cursor_loc[0], cursor_loc[1])
curses.doupdate()
gotch = self.window.getch()
if gotch != -1:
curses.ungetch(gotch)
# self.set_color(self.highlight_color)
curses.setsyx(cursor_loc[0], cursor_loc[1])
curses.doupdate()
def _controller_(self, ch):
"""Control if the character is a control key"""
if ch in [curses.KEY_UP, curses.KEY_DOWN, curses.ascii.TAB,
curses.ascii.CR, curses.ascii.ESC, curses.KEY_MOUSE]:
curses.ungetch(ch)
return curses.ascii.NL
elif ch in [curses.ascii.DEL]:
return curses.ascii.BS
elif curses.ascii.isctrl(ch):
if chr(ch + 64) in self.shortcuts:
curses.ungetch(ch)
return curses.ascii.NL
else:
return ch
def flash(self):
'''Flash this error window'''
if self.visible:
cursor_loc = curses.getsyx()
flash_color = self.highlight_color ^ curses.A_REVERSE
self.set_color(flash_color)
curses.setsyx(cursor_loc[0], cursor_loc[1])
curses.doupdate()
gotch = self.window.getch()
if gotch != -1:
curses.ungetch(gotch)
self.set_color(self.highlight_color)
curses.setsyx(cursor_loc[0], cursor_loc[1])
curses.doupdate()
def read(self, screen):
#insert read book here
screen.erase()
k = -1
selected_page = 0
max_page = len(self.pages) - 1
while k != ord("q"):
screen.erase()
start = 10
for item in self.pages[selected_page]:
if start == 10:
screen.attron(curses.color_pair(135))
if "[" in item:
before, keyword, after = item.split("[")[0], item.split(
"[")[1].split("]")[0], item.split("]")[1]
screen.addstr(start, 34, before)
screen.attron(curses.color_pair(136))
screen.addstr(start, 34 + len(before), keyword)
screen.attroff(curses.color_pair(136))
screen.addstr(start, 34 + len(before) + len(keyword),
after)
else:
screen.addstr(start, 34, item)
if start == 10:
screen.attroff(curses.color_pair(135))
start += 1
if selected_page != 0:
screen.addch(47, 32, curses.ACS_LARROW)
screen.addstr(47, 34,
f"Page {selected_page + 1} of {max_page + 1}")
if selected_page < max_page:
screen.addch(
47,
36 + len(f"Page {selected_page + 1} of {max_page + 1}"),
curses.ACS_RARROW)
k = screen.getch()
if k == curses.KEY_LEFT:
selected_page = max(0, selected_page - 1)
elif k == curses.KEY_RIGHT:
selected_page = min(len(self.pages) - 1, selected_page + 1)
curses.ungetch(curses.KEY_F0)
def test_menu_config_key_resize(self):
"""Test redrawing the window in response to a resize keypress."""
curses.initscr()
curses.ungetch("\n")
curses.ungetch("\n")
curses.ungetch(curses.KEY_RESIZE)
curses.ungetch(curses.KEY_RIGHT)
self.assertTrue(self.menu())
def start(self, timeout=-1):
"""See mother class"""
# Automatic lock screen
counter = 0
timer = Configuration.lock * 60 * 1000 # Timer in ms
while True:
# Start default controller (timeout of 100 ms)
result = TitledOnBorderWindow.start(self, 100)
# Lock screen ?
if result == 'timeout' and timer > 0:
counter += 100
if counter >= timer:
self.parent.lock_screen()
counter = 0
else:
counter = 0
# Try to create or update the block
if result == self.patternEditor:
self.do_search()
# Navigate in result panel
elif result == self.resultPanel:
self.update_status("Navigate or hit return to edit")
result = self.resultPanel.start(timeout=100)
self.update_status("")
if result == -1:
self.index -= 1 # Focus on previous item
elif result == 1 or result is False:
self.index -= 1 # Focus on next item
curses.ungetch(curses.ascii.ESC) # Quit window
elif isinstance(result, Component):
idblock, sib = result.get_data()
# Return number_type, idblock
return int(sib['info1'].decode()), idblock
# Quit window or Escape
elif result == 1 or result == -1 or result is False:
self.index = 0 # For focusing on first item at the return
self.update_status("") # Clear status bar
if self.nbResult == 0:
# Hide pattern editor if there is no result
self.patternEditor.hide()
return False, False
def test_menu_textentryitem__key_up(self):
"""Test that the input_caller returns the expected string value."""
curses.initscr()
curses.ungetch("\n")
curses.ungetch(curses.KEY_UP)
curses.ungetch(curses.KEY_DOWN)
curses.ungetch("a")
self.textentryitem()
self.assertEqual(self.textentryitem.get_value(), "a")
def start(self, timeout=-1):
"""See mother class"""
# Automatic lock screen
counter = 0
timer = Configuration.lock * 60 * 1000 # Timer in ms
while True:
# Start default controller (timeout of 100 ms)
result = TitledOnBorderWindow.start(self, 100)
# Lock screen ?
if result == 'timeout' and timer > 0:
counter += 100
if counter >= timer:
self.parent.lock_screen()
counter = 0
else:
counter = 0
# Try to create or update the block
if result == self.patternEditor:
self.do_search()
# Navigate in result panel
elif result == self.resultPanel:
self.update_status("Navigate or hit return to edit")
result = self.resultPanel.start(timeout=100)
self.update_status("")
if result == -1:
self.index -= 1 # Focus on previous item
elif result == 1 or result is False:
self.index -= 1 # Focus on next item
curses.ungetch(curses.ascii.ESC) # Quit window
elif isinstance(result, Component):
idblock, sib = result.get_data()
# Return number_type, idblock
return int(sib['info1'].decode()), idblock
# Quit window or Escape
elif result == 1 or result == -1 or result is False:
self.index = 0 # For focusing on first item at the return
self.update_status("") # Clear status bar
if self.nbResult == 0:
# Hide pattern editor if there is no result
self.patternEditor.hide()
return False, False
def handlerResize(self, signum="", frame=""):
if self.isInScroll==1:
curses.ungetch("q")
curses.endwin()
self.__init__(1)
curses.ungetch(curses.ascii.NL)
oldH = self.doHistory
oldT = self.timestamp
self.mainWindow.clear()
self.doHistory = False
self.timestamp = False
for histLine in self.history:
self.printMessage(histLine)
self.doHistory = oldH
self.timestamp = oldT
self.setTitle(self.channel,self.peersCount)
curses.curs_set(1)
def SetDatabase(self):
try:
name = self.ActionWidgets[0].Text
result = CDBCore.CDBCore.Connection.SetDatabase(name)
if result.Success:
CDBCore.CDBCore.Connection.Database = name
CDBCore.CDBCore.StatusScreen.AddStatusMessage("Set database to: " + name)
curses.ungetch('\n') # Notify the core to move to next screen
else:
raise Exception(result.Message)
except Exception as ex:
# Could not set the database
msg = "Could not set the database to: " + name
CDBCore.CDBCore.StatusScreen.AddStatusMessage(msg)
self.ActionWidgets[self.CurrentWidget].selected = True
self.ActionWidgets[self.CurrentWidget].Highlight()
self.ActionWidgets[self.CurrentWidget].Active
def edit(self, validate=None, initial_text=None):
"Edit in the widget window and collect the results."
if initial_text is None:
initial_text = ""
initial_text_list = list(initial_text)
while 1:
if initial_text_list:
curses.ungetch(ord(initial_text_list.pop(0)))
ch = self.win.getch()
if validate:
ch = validate(ch)
if not ch:
continue
if not self.do_command(ch):
break
self.win.refresh()
return self.gather()
def modify_matrix(stdscr, tr_x, tr_y, space, rows, cols):
stdscr.keypad(True)
lengths = [[1 for i in range(rows)] for j in range(cols)]
values = [["0" for i in range(cols)] for j in range(rows)]
pos = [0, 0]
stdscr.move(tr_x, tr_y + 1)
while True:
ch = stdscr.getch()
if ch == curses.KEY_UP:
if pos[1] != 0:
pos[1] -= 1
move_newpos(stdscr, tr_x, tr_y, space, rows, cols, lengths,
pos[0], pos[1])
elif ch == curses.KEY_DOWN:
if pos[1] != rows - 1:
pos[1] += 1
move_newpos(stdscr, tr_x, tr_y, space, rows, cols, lengths,
pos[0], pos[1])
elif ch == curses.KEY_RIGHT:
if pos[0] != cols - 1:
pos[0] += 1
move_newpos(stdscr, tr_x, tr_y, space, rows, cols, lengths,
pos[0], pos[1])
elif ch == curses.KEY_LEFT:
if pos[0] != 0:
pos[0] -= 1
move_newpos(stdscr, tr_x, tr_y, space, rows, cols, lengths,
pos[0], pos[1])
else:
try:
if str(ch) == "127":
if (lengths[pos[0]][pos[1]] > 0):
stdscr.addstr("\b \b")
lengths[pos[0]][pos[1]] -= 1
values[pos[1]][pos[0]] = values[pos[1]][pos[0]][:-1]
elif str(ch) == "10":
curses.ungetch(curses.KEY_DOWN)
elif str(ch) == "9":
return values
else:
s = str(chr(int(str(ch))))[0]
lengths[pos[0]][pos[1]] += 1
values[pos[1]][pos[0]] += s
stdscr.addstr(s)
except Exception as _:
return
def bgreaderloop(s):
while 1:
s.statuslock.acquire()
if s.lockheld or s.bgchar == None:
s.statuslock.release()
s.startup.wait()
else:
s.statuslock.release()
ch = s.c.stdscr.getch()
s.statuslock.acquire()
try:
if s.lockheld or s.bgchar == None:
curses.ungetch(ch)
else:
s.bgchar(ch)
finally:
s.statuslock.release()
def bgreaderloop(s):
while 1:
s.statuslock.acquire()
if s.lockheld or s.bgchar == None:
s.statuslock.release()
s.startup.wait()
else:
s.statuslock.release()
ch = s.c.stdscr.getch()
s.statuslock.acquire()
try:
if s.lockheld or s.bgchar == None:
curses.ungetch(ch)
else:
s.bgchar(ch)
finally:
s.statuslock.release()
def edit(self, validate=None, initial_text=None):
"Edit in the widget window and collect the results."
if initial_text is None:
initial_text = ""
initial_text_list = list(initial_text)
while 1:
if initial_text_list:
curses.ungetch(ord(initial_text_list.pop(0)))
ch = self.win.getch()
if validate:
ch = validate(ch)
if not ch:
continue
if not self.do_command(ch):
break
self.win.refresh()
return self.gather()
def kbhit(window, char, no):
ch = window.getch()
if ch == -1:
return 0
try:
nch = int(str(chr(ch)))
except ValueError:
nch = -1
if (nch == char or nch in no):
if (nch == char):
curses.ungetch(ch)
return 1
else:
return 2
else:
return 0
def kbhit(window,char,no):
ch = window.getch();
if ch == -1:
return 0
try:
nch = int(str(chr(ch)))
except ValueError:
nch = -1
if (nch == char or nch in no):
if (nch == char):
curses.ungetch(ch)
return 1
else:
return 2
else:
return 0
def __init__(self,
screen,
area_size,
raw_lines,
base,
margin=5,
print_infos=print):
screen_height, screen_width = area_size
self.outer_margin = margin
self.inner_margin = 2
self.width = screen_width - self.outer_margin * 2
self.text_width = self.width - self.inner_margin * 2
lines = []
for l in raw_lines:
lines.extend(format_string(l, self.text_width, truncate=False))
self.height = len(lines) + 2 # for border
# Compute first line position
if self.height > screen_height:
lines = lines[:screen_height - 2]
lines[-1] = lines[-1][:-1] + '…'
print_infos('Truncated, too many lines!')
self.height = len(lines) + 2
start = max(1, base - int(len(lines) / 2))
if start + self.height - 1 > screen_height:
start = max(1, screen_height + 1 - self.height)
self.win = curses.newwin(self.height, self.width, start,
self.outer_margin)
self.win.bkgd(curses.color_pair(3))
self.win.keypad(1)
self.win.border('|', '|', '-', '-', '+', '+', '+', '+')
for line in range(len(lines)):
self.win.move(line + 1, self.inner_margin)
self.win.addstr(line + 1, self.inner_margin, str(lines[line]))
self.win.refresh()
key = screen.getch()
curses.ungetch(key)
def do_stop(self, line):
'''stop
Shuts down the server gently...ish.'''
global RUNNING
RUNNING=False
#In order to finalize this, we need to wake up all
#threads. Main is awake on a one-second loop, the
#server does acquiry every 5 seconds, and the client
#manager every fraction of a second. Our UIthread will
#respond to a character, so lets put one on there:
if curses:
curses.ungetch('\x00')
elif msvcrt:
msvcrt.putch('\x00')
#else, panic.
#after that's done, all the threads should realize that
#it's time to pack up.
print 'This will take up to 5 seconds...'
def __leaf_01(ql: Qiling):
curses.nonl()
# set non-blocking
ql.os.stdscr.timeout(0)
key = parse_key(ql.os.stdscr.getch())
if key == -1:
ql.os.set_zf()
ql.arch.regs.ax = 0
else:
ql.log.debug(f"Has key: {hex(key)} ({curses.ascii.unctrl(key)})")
ql.arch.regs.al = key
ql.arch.regs.ah = get_scan_code(key)
ql.os.clear_zf()
# Buffer shouldn't be removed in this interrupt.
curses.ungetch(key)
ql.os.stdscr.timeout(-1)
curses.nl()
def startup(self):
self.game_over = False
self.stage.units = []
self.stage.field.clear()
self.main_unit = u.MainUnit('./units/invader',
'invader',
color=curses.COLOR_RED)
self.player = Player(self.player.name, self.stage)
self.stage.build_floor(self.FLOOR_LVL)
self.stage.add_unit(self.main_unit,
20,
self.stage.floor_level.y,
main=True)
self.generator = Generator(self.stage, self.main_unit.width.length(),
self.velocity)
self.stage.bitmap.print_units(self.stage.units, self.main_unit)
# send enter key to start moving the unit
curses.ungetch(10)
self.stage.draw_units2()
def change_focus(self, option_nr):
all = self.inputs + self.options
for opt in all:
index = all.index(opt)
if index == option_nr:
self.selected_index = index
opt.focus = True
if opt.name != 'input':
opt.color = 'selected'
self.pixel_color_change(opt, 'selected')
elif opt.textbox is not None:
curses.curs_set(1)
opt.value = opt.textbox.textbox.edit()
curses.curs_set(0)
# logging.debug(opt.value)
curses.ungetch(10)
else:
opt.focus = False
opt.color = curses.COLOR_WHITE
self.pixel_color_change(opt, curses.COLOR_WHITE)
def _inject_key(screen, char):
"""
Inject a specified character into the input buffers.
"""
if sys.platform == "win32":
event = win32console.PyINPUT_RECORDType(win32console.KEY_EVENT)
event.RepeatCount = 1
event.ControlKeyState = 0
event.VirtualScanCode = 0
if char >= 0:
event.Char = chr(char)
event.VirtualKeyCode = ord(chr(char).upper())
else:
# Lookup in mapping dicts
reverse = dict((v, k) for k, v in
screen._EXTRA_KEY_MAP.items())
if char in reverse:
event.VirtualKeyCode = reverse[char]
else:
# Fudge key state required for BACK_TAB if needed.
if char == Screen.KEY_BACK_TAB:
char = Screen.KEY_TAB
event.ControlKeyState = win32con.SHIFT_PRESSED
reverse = dict((v, k) for k, v in
screen._KEY_MAP.items())
event.VirtualKeyCode = reverse[char]
event.KeyDown = 1
screen._stdin.WriteConsoleInput([event])
event.KeyDown = 0
screen._stdin.WriteConsoleInput([event])
else:
if char > 0:
# Curses uses a LIFO stack for key injection, so reverse the
# byte string to be injected. Note that this still works for
# ASCII as it is a single char subset of UTF-8.
for c in reversed(bytes(chr(char).encode("utf-8"))):
curses.ungetch(c)
else:
reverse = dict((v, k) for k, v in
screen._KEY_MAP.items())
curses.ungetch(reverse[char])
def time_task(offset):
"""Log time to task.
:param offset: Current offset of task pad
Display time logged every second and write it to the task when finished.
"""
item = current_item(task_pad, offset)
task = items[item]
t0 = datetime.now()
status = "Started at %s" % datetime.now().strftime("%H:%M")
write_status(status)
# With halfdelay on, getch returns -1 every second if no key is pressed
curses.halfdelay(10)
while 1:
c = stdscr.getch()
t1 = datetime.now()
logged_time = t1 - t0
if c == -1:
logged_str = str(logged_time).split('.')[0]
timed_status = "%s -- %s" % (status, logged_str)
write_status(timed_status)
elif c == ord('+'):
edit_time(task, 'add')
# Restore halfdelay to continue timer
curses.halfdelay(10)
elif c == ord('-'):
edit_time(task, 'sub')
# Restore halfdelay to continue timer
curses.halfdelay(10)
elif c == ord('t'):
stop_timer(task, logged_time)
curses.cbreak()
break
elif c == ord('q'):
stop_timer(task, logged_time)
# Pass 'q' to next getch in the main loop, so we can quit from here
curses.ungetch('q')
break
def process(self, input_key):
'''Process a keystroke. For an EditField, this means preparing the
textpad for processing and passing the input_key in.
Try to enable the blinking cursor (if it was disabled) before
editing begins, so the user can see where they're typing. Once
finished, restore the cursor state to its previous condition.
After editing, return self.input_key, which will either be None
(indicating all keystrokes were processed by the Textbox) or
a special character (such as F2) which caused EditField.handle_input
to stop processing text through the Textbox.
'''
try:
curses.curs_set(2)
except curses.error:
terminalui.LOGGER.debug("Got curses.error when enabling cursor")
if input_key is not None and not self.is_special_char(input_key):
# Put input_key back on stack so that textbox.edit can read it
curses.ungetch(input_key)
if self.numeric_pad is not None:
self._set_text(self.get_text().lstrip(self.numeric_pad),
do_pad=False)
if self.clear_on_enter:
self.clear_text()
else:
# Move to end of previous input.
self.textbox.do_command(EditField.CMD_MV_EOL)
self.edit_loop()
return_key = self.input_key
if self.numeric_pad is not None:
self._set_text(self.get_text())
else:
return_key = input_key
terminalui.LOGGER.debug("Returning: %s", return_key)
return return_key
def MakeActive(self):
self.CursorActive = True
self.UpdateLogLabels()
while self.CursorActive:
currentLabelIndex = 1 + self.TotalLabelsInScreen - (self.CursorPos - self.LogDisplayPos)
try:
key = self.PassiveWidgets[currentLabelIndex].Win.getch()
except:
CDBCore.CDBCore.StatusScreen.AddStatusMessage("Error displaying messages. Exiting message log")
self.CursorPos = 0
self.CursorActive = False
self.UpdateLogLabels()
curses.ungetch(key)
return
if key in [curses.KEY_DOWN, ord("s")]:
if self.CursorPos > 0:
self.CursorPos -= 1
if self.LogDisplayPos > self.CursorPos:
self.LogDisplayPos = self.CursorPos
self.UpdateLogLabels()
elif key in [curses.KEY_UP, ord("w")]:
if self.CursorPos < (len(self.Log) - 1):
self.CursorPos += 1
if self.LogDisplayPos < self.CursorPos - self.TotalLabelsInScreen + 1:
self.LogDisplayPos += 1
self.UpdateLogLabels()
elif key in [curses.KEY_F8, 76]: # SHIFT-L or F8 all exit message log
# exit for screen
self.CursorPos = 0
self.CursorActive = False
self.UpdateLogLabels()
curses.ungetch(key)
elif key in [ord("\n"), 10]: # ENTER
if len(self.Log) > 0:
self.DisplayPopUpMessage(self.Log[self.CursorPos])
self.UpdateLogLabels()
def Active(self):
selected = True
# highlight current widget to show it is active
self.Highlight()
while selected:
key = self.Win.getch()
# capture ENTER, TAB, and BACKTAB keystrokes
if key in [curses.KEY_ENTER, ord("\n"), 10]:
self.Check()
elif key in [ord("\t"), 9]:
# stop highlighting current widget
self.UnHighlight()
selected = False
curses.ungetch(key)
# go to menu (SHIFT-M or F1)
# or go to status screen (SHIFT-M or F8)
elif key in [curses.KEY_F1, 77, curses.KEY_F8, 76] and not self.DisableScreenSwitch:
selected = False
curses.ungetch(key)
