def set_trace_level(self, flag, val, change_cb=True):
""" Set trace level, changing Control button if requested
:flag: - trace flag name
:val: - value to set
:change_cb: True(default) appropriately change the control
"""
if flag not in self.data_by_flag:
SlTrace.lg("set_trace_level(%s,%d) - flag has no check button" % (flag, val))
return
cb, flag, var = self.data_by_flag[flag]
if cb is None:
SlTrace.lg("set_trace_level(%s,%d) - flag None check button" % (flag, val))
return
if change_cb and hasattr(cb, "select"):
if val != 0:
cb.select()
else:
cb.deselect()
SlTrace.lg("flag=%s, var=%s, val=%s" %(flag, var, val), "trace_flags")
SlTrace.setLevel(flag, val)
if self.change_call is not None:
self.change_call(flag, val)
if __name__ == '__main__':
def report_change(flag, val, cklist=None):
SlTrace.lg("changed: %s = %d" % (flag, val))
new_val = SlTrace.getLevel(flag)
SlTrace.lg("New val: %s = %d" % (flag, new_val))
if cklist is not None:
cklist.list_ckbuttons()
root = Tk()
SlTrace.set_mw(root)
###frame = Frame(root)
###frame.pack()
SlTrace.setProps()
SlTrace.setFlags("flag1=t,flag2=f,flag3=t,flag4=10, flag5=20. flag6=abc")
threshold = 5
SlTrace.setLevel("tint1", 5)
end_level = 100
quit_set = False
def our_quit(flag=None):
""" Test for traceButton
:flag: flag arg
"""
global quit_set
if flag is None:
flag = "TBD"
SlTrace.lg(f"our_quit({flag})")
SlTrace.report("Quitting Program")
root.destroy
quit_set = True
sys.exit()
def do_stcmd(self, stcmd):
""" Execute play command
:stcmd: command (py)
:returns: True if succesful
"""
stcmd_name = stcmd.name
if SlTrace.trace("stcmd_list"):
SlTrace.lg(" %s" % (stcmd))
if stcmd_name == "execute_file":
file_name = self.get_arg(stcmd, 1, "")
return self.play_control.cmd_stream.procFile(file_name)
if stcmd_name.lower() == "eof":
self.command_stream.set_eof()
return True
if stcmd_name == "lg":
""" Version of Sl1Trace.lg(text[ flag_string})
:args[0] text to log
:args[1]: optional flag to enable logging default: log it
"""
if len(stcmd.args) == 0:
raise SelectError("Required text argument is missing")
text = stcmd.args[0].str
totrace = True # Default - list
if len(stcmd.args) >= 2:
flag = stcmd.args[1].str
if not SlTrace.trace(flag):
totrace = False
if totrace:
SlTrace.lg(text)
return True
if stcmd_name == "doc_string":
return True
if stcmd_name == "enter":
return self.do_stcmd_enter(stcmd)
if stcmd_name == "set_level":
""" pgm version of SlTrace.set_level(flag, level)
"""
if len(stcmd.args) >= 1:
flag = stcmd.args[0].str
else:
raise SelectError("Missing set_level flag arg")
if len(stcmd.args) >= 2:
level = int(stcmd.args[1].str)
else:
level = 1
SlTrace.setLevel(flag, level)
return True
if (stcmd_name == "up" or stcmd_name == "down" or stcmd_name == "left"
or stcmd_name == "right" or stcmd_name == "plus"
or stcmd_name == "minus"):
res = self.stcmd_move_edge(stcmd)
return res
if stcmd_name == "help": # Help
SlTrace.lg("""
space - Add multiline blank delimiter
a - add delimiter with one line of text
b - list blinking parts
c - clear current part display
d - (re)display current part
f - rurn current part off
h - Output this help listing
i - list part, edges of current location
j - List edge at current edge position
k - cmds at top of cmd stack
g - List on square(s) touching current edge
l - List highlighted parts
n - turn on current part
r - redo undone command
s - list selected parts
t - list parts that are turned on
v - set current edge
Selection movement directions:
UP
Down
Left
Right
"plus" - rotate selection clockwise
"minus" - rotate selection counter clockwise
; - multi character command
c[anvas] pattern - list canvas objects with tag "ALL" - all canvas objects
p[part] pattern - List parts with tag, default all parts (one entry per part)
r[ecord] pattern - Trace canvas rectangles with any tag matching pattern
s[tart] number[current] - start(restart) looking at tracking number
d[elete] pattern(default .*) delete canvas objects
<cmd>[s]t=[<stack_length>][:<stack_bottom>]] Add stack listing
<stack_length> - number of levels listed default: 2
<stack_bottom> - bottom of stack listed (0-most recent) default: 2 above
Examples: pt=5 - to parts add stack list of 5 levels
pt= - add default stack list to parts
pt=6:3 - add stack 6 levels, omitting 3 lowest levels
""")
return True
if stcmd_name == "space":
""" List separator
:args[0]: optional annotation text if present
"""
SlTrace.lg("_" * 50 + "\n\n\n")
if len(stcmd.args) >= 1:
SlTrace.lg(stcmd.args[0].str)
return True
if stcmd_name == "blinking": # List "Blinking" parts
self.list_blinking("blinking")
return True
if stcmd_name == "stack": # cmds at top of stack
self.play_control.command_manager.list_stack()
if stcmd_name == "lighted":
part_ids = list(self.play_control.board.area.highlights)
SlTrace.lg("Highlighted parts(%d):" % len(part_ids))
for part_id in part_ids:
part = self.get_part(id=part_id)
SlTrace.lg(" %s" % part)
return True
if stcmd_name == "select":
return self.select(stcmd)
if stcmd_name == "selected": # List those selected
self.list_selected()
return True
if stcmd_name == "turnedon": # List those turned on
part_ids = list(self.play_control.board.area.parts_by_id)
n_on = 0
for part_id in part_ids:
part = self.get_part(id=part_id)
if part.is_turned_on():
n_on += 1
SlTrace.lg("parts turned on(%d of %d):" % (n_on, len(part_ids)))
for part_id in part_ids:
part = self.get_part(id=part_id)
if part.is_turned_on():
SlTrace.lg(" %s" % part)
return
if stcmd_name == "set_edge":
return self.do_stcmd("enter")
if stcmd_name == "set_playing":
return self.set_playing(stcmd)
if stcmd_name == "set_player":
return self.set_player(stcmd)
if stcmd_name == "redo":
nt = 1
if stcmd.args:
nt = int(stcmd.args[0].str)
for i in range(nt):
res = self.play_control.redo()
if not res:
break
return res
if stcmd_name == "info": # Do info on squares(regions) touching current edge
edge = self.get_keycmd_edge()
SlTrace.lg("%s" % edge.str_adjacents())
return True
if stcmd_name == "undo":
nt = 1
if stcmd.args:
nt = int(stcmd.args[0].str)
for i in range(nt):
res = self.play_control.undo()
if not res:
break
return res
if stcmd_name == "canvas":
canvas = self.get_canvas()
if len(stcmd.args) >= 1:
pat = stcmd.args[0].str
else:
pat = ".*"
items = canvas.get_tracked()
matching_ids = []
for item in items:
(rec_id, track_no, call_stack) = item
tags = canvas.gettags(rec_id)
for tag in tags:
if re.match(pat, tag):
matching_ids.append(rec_id)
break
SlTrace.lg("canvas %s: %s" % (pat, matching_ids))
return True
if stcmd_name == "delete":
canvas = self.get_canvas()
if len(stcmd.args) >= 1:
pat = stcmd.args[0].str
else:
pat = ".*"
items = canvas.get_tracked()
for item in items:
(rec_id, track_no, call_stack) = item
tags = canvas.gettags(rec_id)
for tag in tags:
SlTrace.lg("tag:%s" % tag)
if re.match(pat, tag):
SlTrace.lg("deleting: %s: %s" % (tags, rec_id))
canvas.delete(rec_id)
break
return True
if stcmd_name == "parts":
canvas = self.get_canvas()
if len(stcmd.args) >= 1:
pat = stcmd.args[0].str
else:
pat = ".*"
items = canvas.get_tracked()
matching_parts_by_id = {}
for item in items:
(rec_id, stack_no, stack) = item
tags = canvas.gettags(rec_id)
part = self.get_part_from_tags(tags)
if part is None:
continue
part_str = str(part)
found = re.search(pat, part_str)
if found:
part_item = (part, item)
if part.part_id not in matching_parts_by_id:
matching_parts_by_id[part.part_id] = [
] # Create list of tags
matching_parts_by_id[part.part_id].append(part_item)
SlTrace.lg("parts pat:%s" % (pat))
for part_id, part_item_list in matching_parts_by_id.items():
part = self.get_part(part_id)
SlTrace.lg(" %d (%d parts)" %
(part.part_id, len(part_item_list)))
for part_item in part_item_list:
part, item = part_item
rec_id, track_no, stack = item
tags = canvas.gettags(rec_id)
pt = self.get_part_from_tags(tags)
SlTrace.lg(" %d %s %s" % (rec_id, track_no, pt))
if self.stack_trace:
rec_id, stack_no, stack = item
canvas.trace_item(prefix=" ",
rec_id=rec_id,
begin=self.stack_begin,
end=self.stack_end)
return True
if stcmd_name == "parts":
canvas = self.get_canvas()
if len(stcmd.args) >= 1:
pat = stcmd.args[0].str
else:
pat = ".*"
items = canvas.get_tracked()
return False # TBD
if stcmd_name == "rectangles":
canvas = self.get_canvas()
if len(stcmd.args) >= 1:
pat = stcmd.args[0].str
else:
pat = ".*"
items = canvas.get_tracked()
for item in items:
(rec_id, track_no, call_stack) = item
tags = canvas.gettags(rec_id)
for tag in tags:
if re.match(pat, tag):
canvas.trace_item(rec_id=rec_id)
break
return True
if stcmd_name == "set_start":
canvas = self.get_canvas()
if len(stcmd.args) >= 1:
num = int(stcmd.args[0].str)
else:
num = self.get_start_track()
canvas = self.get_canvas()
SlTrace.lg("Track no set to: %d" % num)
self.set_start_track(num)
return True
if stcmd_name == "stack":
self.play_control.command_manager.list_stack()
return True
raise SelectError(f"Unsuported command {stcmd}")
return False
