forked from bartvdbraak/blender
2f74b5a260
* interactive console python console. * display reports and filter types. defaults to operator display so you can see the python commands for tools as you use them, eventually it should be possible to select commands and make macto/tools from them. Example use of autocomp. b<tab>, bpy.<tab>, bpy.<tab>, bpy.data.<tab> etc. basic instructions are printed when opening the console. Details... * Console exec and autocomp are done with operators written in python. * added CTX_wm_reports() to get the global report list. * The window manager had a report ListBase but reports have their own struct, switched to allocate and assign when initializing the WM since the type is not available in DNA. * changed report types flags for easier display filtering. * added report type RPT_OPERATOR * logging operators also adds a python-syntax report into CTX_wm_reports() so they can be displayed in the console as well as calling a notifier for console to redraw. * RnaAPI context.area.tag_redraw() to redraw the current area from a python operator. Todo... * better interactions with the console, scrolling, copy/paste. * the text displayed doesnt load back. * colors need to be themed. * scroll limit needs to be a user pref. * only tested with cmake and scons.
418 lines
9.6 KiB
Python
418 lines
9.6 KiB
Python
|
|
import bpy
|
|
|
|
class CONSOLE_HT_header(bpy.types.Header):
|
|
__space_type__ = "CONSOLE"
|
|
__idname__ = "CONSOLE_HT_header"
|
|
|
|
def draw(self, context):
|
|
sc = context.space_data
|
|
# text = sc.text
|
|
layout = self.layout
|
|
|
|
layout.template_header()
|
|
|
|
if context.area.show_menus:
|
|
row = layout.row()
|
|
row.itemM("CONSOLE_MT_console")
|
|
|
|
row = layout.row()
|
|
row.scale_x = 0.9
|
|
row.itemR(sc, "type", expand=True)
|
|
if sc.type == 'REPORT':
|
|
row.itemR(sc, "show_report_debug")
|
|
row.itemR(sc, "show_report_info")
|
|
row.itemR(sc, "show_report_operator")
|
|
row.itemR(sc, "show_report_warn")
|
|
row.itemR(sc, "show_report_error")
|
|
|
|
|
|
class CONSOLE_MT_console(bpy.types.Menu):
|
|
__space_type__ = "CONSOLE"
|
|
__label__ = "Console"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
sc = context.space_data
|
|
|
|
layout.column()
|
|
layout.itemO("CONSOLE_OT_clear")
|
|
|
|
def add_scrollback(text, text_type):
|
|
for l in text.split('\n'):
|
|
bpy.ops.CONSOLE_OT_scrollback_append(text=l.replace('\t', ' '), type=text_type)
|
|
|
|
def get_console(console_id):
|
|
'''
|
|
helper function for console operators
|
|
currently each text datablock gets its own console - code.InteractiveConsole()
|
|
...which is stored in this function.
|
|
|
|
console_id can be any hashable type
|
|
'''
|
|
import sys, code, io
|
|
|
|
try: consoles = get_console.consoles
|
|
except:consoles = get_console.consoles = {}
|
|
|
|
# clear all dead consoles, use text names as IDs
|
|
# TODO, find a way to clear IDs
|
|
'''
|
|
for console_id in list(consoles.keys()):
|
|
if console_id not in bpy.data.texts:
|
|
del consoles[id]
|
|
'''
|
|
|
|
try:
|
|
namespace, console, stdout, stderr = consoles[console_id]
|
|
except:
|
|
namespace = {'__builtins__':__builtins__} # locals()
|
|
namespace['bpy'] = bpy
|
|
|
|
console = code.InteractiveConsole(namespace)
|
|
|
|
if sys.version.startswith('2'):
|
|
stdout = io.BytesIO() # Py2x support
|
|
stderr = io.BytesIO()
|
|
else:
|
|
stdout = io.StringIO()
|
|
stderr = io.StringIO()
|
|
|
|
consoles[console_id]= namespace, console, stdout, stderr
|
|
|
|
return namespace, console, stdout, stderr
|
|
|
|
class CONSOLE_OT_exec(bpy.types.Operator):
|
|
'''
|
|
Operator documentatuon text, will be used for the operator tooltip and python docs.
|
|
'''
|
|
__label__ = "Console Execute"
|
|
|
|
# Both prompts must be the same length
|
|
PROMPT = '>>> '
|
|
PROMPT_MULTI = '... '
|
|
|
|
# is this working???
|
|
'''
|
|
def poll(self, context):
|
|
return (context.space_data.type == 'PYTHON')
|
|
''' # its not :|
|
|
|
|
def execute(self, context):
|
|
import sys
|
|
|
|
sc = context.space_data
|
|
|
|
try:
|
|
line = sc.history[-1].line
|
|
except:
|
|
return ('CANCELLED',)
|
|
|
|
if sc.type != 'PYTHON':
|
|
return ('CANCELLED',)
|
|
|
|
namespace, console, stdout, stderr = get_console(hash(context.region))
|
|
|
|
# redirect output
|
|
sys.stdout = stdout
|
|
sys.stderr = stderr
|
|
|
|
# run the console
|
|
if not line.strip():
|
|
line_exec = '\n' # executes a multiline statement
|
|
else:
|
|
line_exec = line
|
|
|
|
is_multiline = console.push(line_exec)
|
|
|
|
stdout.seek(0)
|
|
stderr.seek(0)
|
|
|
|
output = stdout.read()
|
|
output_err = stderr.read()
|
|
|
|
# cleanup
|
|
sys.stdout = sys.__stdout__
|
|
sys.stderr = sys.__stderr__
|
|
sys.last_traceback = None
|
|
|
|
# So we can reuse, clear all data
|
|
stdout.truncate(0)
|
|
stderr.truncate(0)
|
|
|
|
bpy.ops.CONSOLE_OT_scrollback_append(text = sc.prompt+line, type='INPUT')
|
|
|
|
if is_multiline: sc.prompt = self.PROMPT_MULTI
|
|
else: sc.prompt = self.PROMPT
|
|
|
|
# insert a new blank line
|
|
bpy.ops.CONSOLE_OT_history_append(text="", current_character=0)
|
|
|
|
# Insert the output into the editor
|
|
# not quite correct because the order might have changed, but ok 99% of the time.
|
|
if output: add_scrollback(output, 'OUTPUT')
|
|
if output_err: add_scrollback(output_err, 'ERROR')
|
|
|
|
|
|
return ('FINISHED',)
|
|
|
|
|
|
def autocomp(bcon):
|
|
'''
|
|
This function has been taken from a BGE console autocomp I wrote a while ago
|
|
the dictionaty bcon is not needed but it means I can copy and paste from the old func
|
|
which works ok for now.
|
|
|
|
could be moved into its own module.
|
|
'''
|
|
|
|
|
|
def is_delimiter(ch):
|
|
'''
|
|
For skipping words
|
|
'''
|
|
if ch == '_':
|
|
return False
|
|
if ch.isalnum():
|
|
return False
|
|
|
|
return True
|
|
|
|
def is_delimiter_autocomp(ch):
|
|
'''
|
|
When autocompleteing will earch back and
|
|
'''
|
|
if ch in '._[] "\'':
|
|
return False
|
|
if ch.isalnum():
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
def do_autocomp(autocomp_prefix, autocomp_members):
|
|
'''
|
|
return text to insert and a list of options
|
|
'''
|
|
autocomp_members = [v for v in autocomp_members if v.startswith(autocomp_prefix)]
|
|
|
|
print("AUTO: '%s'" % autocomp_prefix)
|
|
print("MEMBERS: '%s'" % str(autocomp_members))
|
|
|
|
if not autocomp_prefix:
|
|
return '', autocomp_members
|
|
elif len(autocomp_members) > 1:
|
|
# find a common string between all members after the prefix
|
|
# 'ge' [getA, getB, getC] --> 'get'
|
|
|
|
# get the shortest member
|
|
min_len = min([len(v) for v in autocomp_members])
|
|
|
|
autocomp_prefix_ret = ''
|
|
|
|
for i in range(len(autocomp_prefix), min_len):
|
|
char_soup = set()
|
|
for v in autocomp_members:
|
|
char_soup.add(v[i])
|
|
|
|
if len(char_soup) > 1:
|
|
break
|
|
else:
|
|
autocomp_prefix_ret += char_soup.pop()
|
|
|
|
print(autocomp_prefix_ret)
|
|
return autocomp_prefix_ret, autocomp_members
|
|
elif len(autocomp_members) == 1:
|
|
return autocomp_members[0][len(autocomp_prefix):], []
|
|
else:
|
|
return '', []
|
|
|
|
|
|
def BCon_PrevChar(bcon):
|
|
cursor = bcon['cursor']-1
|
|
if cursor<0:
|
|
return None
|
|
|
|
try:
|
|
return bcon['edit_text'][cursor]
|
|
except:
|
|
return None
|
|
|
|
|
|
def BCon_NextChar(bcon):
|
|
try:
|
|
return bcon['edit_text'][bcon['cursor']]
|
|
except:
|
|
return None
|
|
|
|
def BCon_cursorLeft(bcon):
|
|
bcon['cursor'] -= 1
|
|
if bcon['cursor'] < 0:
|
|
bcon['cursor'] = 0
|
|
|
|
def BCon_cursorRight(bcon):
|
|
bcon['cursor'] += 1
|
|
if bcon['cursor'] > len(bcon['edit_text']):
|
|
bcon['cursor'] = len(bcon['edit_text'])
|
|
|
|
def BCon_AddScrollback(bcon, text):
|
|
|
|
bcon['scrollback'] = bcon['scrollback'] + text
|
|
|
|
|
|
def BCon_cursorInsertChar(bcon, ch):
|
|
if bcon['cursor']==0:
|
|
bcon['edit_text'] = ch + bcon['edit_text']
|
|
elif bcon['cursor']==len(bcon['edit_text']):
|
|
bcon['edit_text'] = bcon['edit_text'] + ch
|
|
else:
|
|
bcon['edit_text'] = bcon['edit_text'][:bcon['cursor']] + ch + bcon['edit_text'][bcon['cursor']:]
|
|
|
|
bcon['cursor']
|
|
if bcon['cursor'] > len(bcon['edit_text']):
|
|
bcon['cursor'] = len(bcon['edit_text'])
|
|
BCon_cursorRight(bcon)
|
|
|
|
|
|
TEMP_NAME = '___tempname___'
|
|
|
|
cursor_orig = bcon['cursor']
|
|
|
|
ch = BCon_PrevChar(bcon)
|
|
while ch != None and (not is_delimiter(ch)):
|
|
ch = BCon_PrevChar(bcon)
|
|
BCon_cursorLeft(bcon)
|
|
|
|
if ch != None:
|
|
BCon_cursorRight(bcon)
|
|
|
|
#print (cursor_orig, bcon['cursor'])
|
|
|
|
cursor_base = bcon['cursor']
|
|
|
|
autocomp_prefix = bcon['edit_text'][cursor_base:cursor_orig]
|
|
|
|
print("PREFIX:'%s'" % autocomp_prefix)
|
|
|
|
# Get the previous word
|
|
if BCon_PrevChar(bcon)=='.':
|
|
BCon_cursorLeft(bcon)
|
|
ch = BCon_PrevChar(bcon)
|
|
while ch != None and is_delimiter_autocomp(ch)==False:
|
|
ch = BCon_PrevChar(bcon)
|
|
BCon_cursorLeft(bcon)
|
|
|
|
cursor_new = bcon['cursor']
|
|
|
|
if ch != None:
|
|
cursor_new+=1
|
|
|
|
pytxt = bcon['edit_text'][cursor_new:cursor_base-1].strip()
|
|
print("AUTOCOMP EVAL: '%s'" % pytxt)
|
|
#try:
|
|
if pytxt:
|
|
bcon['console'].runsource(TEMP_NAME + '=' + pytxt, '<input>', 'single')
|
|
# print val
|
|
else: ##except:
|
|
val = None
|
|
|
|
try:
|
|
val = bcon['namespace'][TEMP_NAME]
|
|
del bcon['namespace'][TEMP_NAME]
|
|
except:
|
|
val = None
|
|
|
|
if val:
|
|
autocomp_members = dir(val)
|
|
|
|
autocomp_prefix_ret, autocomp_members = do_autocomp(autocomp_prefix, autocomp_members)
|
|
|
|
bcon['cursor'] = cursor_orig
|
|
for v in autocomp_prefix_ret:
|
|
BCon_cursorInsertChar(bcon, v)
|
|
cursor_orig = bcon['cursor']
|
|
|
|
if autocomp_members:
|
|
BCon_AddScrollback(bcon, ', '.join(autocomp_members))
|
|
|
|
del val
|
|
|
|
else:
|
|
# Autocomp global namespace
|
|
autocomp_members = bcon['namespace'].keys()
|
|
|
|
if autocomp_prefix:
|
|
autocomp_members = [v for v in autocomp_members if v.startswith(autocomp_prefix)]
|
|
|
|
autocomp_prefix_ret, autocomp_members = do_autocomp(autocomp_prefix, autocomp_members)
|
|
|
|
bcon['cursor'] = cursor_orig
|
|
for v in autocomp_prefix_ret:
|
|
BCon_cursorInsertChar(bcon, v)
|
|
cursor_orig = bcon['cursor']
|
|
|
|
if autocomp_members:
|
|
BCon_AddScrollback(bcon, ', '.join(autocomp_members))
|
|
|
|
bcon['cursor'] = cursor_orig
|
|
|
|
|
|
class CONSOLE_OT_autocomplete(bpy.types.Operator):
|
|
'''
|
|
Operator documentatuon text, will be used for the operator tooltip and python docs.
|
|
'''
|
|
__label__ = "Console Autocomplete"
|
|
|
|
def poll(self, context):
|
|
return context.space_data.type == 'PYTHON'
|
|
|
|
def execute(self, context):
|
|
|
|
sc = context.space_data
|
|
|
|
namespace, console, stdout, stderr = get_console(hash(context.region))
|
|
|
|
current_line = sc.history[-1]
|
|
line = current_line.line
|
|
|
|
if not console:
|
|
return ('CANCELLED',)
|
|
|
|
if sc.type != 'PYTHON':
|
|
return ('CANCELLED',)
|
|
|
|
# fake cursor, use for autocomp func.
|
|
bcon = {}
|
|
bcon['cursor'] = current_line.current_character
|
|
bcon['console'] = console
|
|
bcon['edit_text'] = line
|
|
bcon['namespace'] = namespace
|
|
bcon['scrollback'] = '' # nor from the BGE console
|
|
|
|
|
|
# This function isnt aware of the text editor or being an operator
|
|
# just does the autocomp then copy its results back
|
|
autocomp(bcon)
|
|
|
|
# Now we need to copy back the line from blender back into the text editor.
|
|
# This will change when we dont use the text editor anymore
|
|
if bcon['scrollback']:
|
|
add_scrollback(bcon['scrollback'], 'INFO')
|
|
|
|
# copy back
|
|
current_line.line = bcon['edit_text']
|
|
current_line.current_character = bcon['cursor']
|
|
|
|
context.area.tag_redraw()
|
|
|
|
return ('FINISHED',)
|
|
|
|
|
|
|
|
bpy.types.register(CONSOLE_HT_header)
|
|
bpy.types.register(CONSOLE_MT_console)
|
|
|
|
bpy.ops.add(CONSOLE_OT_exec)
|
|
bpy.ops.add(CONSOLE_OT_autocomplete)
|
|
|