|
|
|
@ -78,7 +78,7 @@ import os |
|
|
|
pwd = os.getcwd() # make sure we're executing from the correct directory level |
|
|
|
pwd = pwd.replace('\\', '/') |
|
|
|
if 0 <= pwd.find('buildroot/share/atom'): |
|
|
|
pwd = pwd[ : pwd.find('buildroot/share/atom')] |
|
|
|
pwd = pwd[:pwd.find('buildroot/share/atom')] |
|
|
|
os.chdir(pwd) |
|
|
|
print('pwd: ', pwd) |
|
|
|
|
|
|
|
@ -118,8 +118,6 @@ from datetime import datetime, date, time |
|
|
|
# reboot |
|
|
|
######### |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
########################################################################################## |
|
|
|
# |
|
|
|
# popup to get input from user |
|
|
|
@ -128,74 +126,78 @@ from datetime import datetime, date, time |
|
|
|
|
|
|
|
def get_answer(board_name, cpu_label_txt, cpu_a_txt, cpu_b_txt): |
|
|
|
|
|
|
|
|
|
|
|
if python_ver == 2: |
|
|
|
import Tkinter as tk |
|
|
|
else: |
|
|
|
import tkinter as tk |
|
|
|
|
|
|
|
def CPU_exit_3(): # forward declare functions |
|
|
|
|
|
|
|
CPU_exit_3_() |
|
|
|
def CPU_exit_4(): |
|
|
|
|
|
|
|
CPU_exit_4_() |
|
|
|
def got_answer(): |
|
|
|
got_answer_() |
|
|
|
|
|
|
|
def kill_session(): |
|
|
|
kill_session_() |
|
|
|
|
|
|
|
root_get_answer = tk.Tk() |
|
|
|
root_get_answer.attributes("-topmost", True) |
|
|
|
root_get_answer.title('') |
|
|
|
root_get_answer.withdraw() |
|
|
|
root_get_answer.deiconify() |
|
|
|
|
|
|
|
root_get_answer.chk_state_1 = 1 # declare variables used by TK and enable |
|
|
|
def disable_event(): |
|
|
|
pass |
|
|
|
|
|
|
|
chk_state_1 = 0 # set initial state of check boxes |
|
|
|
root_get_answer.protocol("WM_DELETE_WINDOW", disable_event) |
|
|
|
root_get_answer.resizable(False, False) |
|
|
|
|
|
|
|
root_get_answer.radio_state = 1 # declare variables used by TK and enable |
|
|
|
|
|
|
|
global get_answer_val |
|
|
|
get_answer_val = 2 # return get_answer_val, set default to match chk_state_1 default |
|
|
|
|
|
|
|
|
|
|
|
l1 = tk.Label(text=board_name, |
|
|
|
fg = "light green", |
|
|
|
bg = "dark green", |
|
|
|
font = "Helvetica 12 bold").grid(row=1) |
|
|
|
|
|
|
|
l2 = tk.Label(text=cpu_label_txt, |
|
|
|
fg = "light green", |
|
|
|
bg = "dark green", |
|
|
|
font = "Helvetica 16 bold italic").grid(row=2) |
|
|
|
|
|
|
|
b4 = tk.Checkbutton(text=cpu_a_txt, |
|
|
|
fg = "black", |
|
|
|
font = "Times 20 bold ", |
|
|
|
variable=chk_state_1, onvalue=1, offvalue=0, |
|
|
|
|
|
|
|
command = CPU_exit_3).grid(row=3) |
|
|
|
|
|
|
|
b5 = tk.Checkbutton(text=cpu_b_txt, |
|
|
|
fg = "black", |
|
|
|
font = "Times 20 bold ", |
|
|
|
variable=chk_state_1, onvalue=0, offvalue=1, |
|
|
|
|
|
|
|
command = CPU_exit_4).grid(row=4) # use same variable but inverted so they will track |
|
|
|
b6 = tk.Button(text="CONFIRM", |
|
|
|
fg = "blue", |
|
|
|
font = "Times 20 bold ", |
|
|
|
command = root_get_answer.destroy).grid(row=5, pady=4) |
|
|
|
|
|
|
|
b7 = tk.Button(text="CANCEL", |
|
|
|
fg = "red", |
|
|
|
font = "Times 12 bold ", |
|
|
|
command = kill_session).grid(row=6, pady=4) |
|
|
|
|
|
|
|
get_answer_val = 2 # return get_answer_val, set default to match radio_state default |
|
|
|
|
|
|
|
radio_state = tk.IntVar() |
|
|
|
radio_state.set(get_answer_val) |
|
|
|
|
|
|
|
l1 = tk.Label(text=board_name, fg="light green", bg="dark green", |
|
|
|
font="default 14 bold").grid(row=0, columnspan=2, sticky='EW', ipadx=2, ipady=2) |
|
|
|
|
|
|
|
l2 = tk.Label(text=cpu_label_txt).grid(row=1, pady=4, columnspan=2, sticky='EW') |
|
|
|
|
|
|
|
b4 = tk.Radiobutton( |
|
|
|
text=cpu_a_txt, |
|
|
|
fg="black", |
|
|
|
bg="lightgray", |
|
|
|
relief=tk.SUNKEN, |
|
|
|
selectcolor="green", |
|
|
|
variable=radio_state, |
|
|
|
value=1, |
|
|
|
indicatoron=0, |
|
|
|
command=CPU_exit_3 |
|
|
|
).grid(row=2, pady=1, ipady=2, ipadx=10, columnspan=2) |
|
|
|
|
|
|
|
b5 = tk.Radiobutton( |
|
|
|
text=cpu_b_txt, |
|
|
|
fg="black", |
|
|
|
bg="lightgray", |
|
|
|
relief=tk.SUNKEN, |
|
|
|
selectcolor="green", |
|
|
|
variable=radio_state, |
|
|
|
value=2, |
|
|
|
indicatoron=0, |
|
|
|
command=CPU_exit_3 |
|
|
|
).grid(row=3, pady=1, ipady=2, ipadx=10, columnspan=2) # use same variable but inverted so they will track |
|
|
|
|
|
|
|
b6 = tk.Button(text="Cancel", fg="red", command=kill_session).grid(row=4, column=0, padx=4, pady=4, ipadx=2, ipady=2) |
|
|
|
|
|
|
|
b7 = tk.Button(text="Continue", fg="green", command=got_answer).grid(row=4, column=1, padx=4, pady=4, ipadx=2, ipady=2) |
|
|
|
|
|
|
|
def got_answer_(): |
|
|
|
root_get_answer.destroy() |
|
|
|
|
|
|
|
def CPU_exit_3_(): |
|
|
|
global get_answer_val |
|
|
|
get_answer_val = 1 |
|
|
|
|
|
|
|
def CPU_exit_4_(): |
|
|
|
global get_answer_val |
|
|
|
get_answer_val = 2 |
|
|
|
get_answer_val = radio_state.get() |
|
|
|
|
|
|
|
def kill_session_(): |
|
|
|
raise SystemExit(0) # kill everything |
|
|
|
@ -214,12 +216,12 @@ def resolve_path(path): |
|
|
|
# turn the selection into a partial path |
|
|
|
|
|
|
|
if 0 <= path.find('"'): |
|
|
|
path = path[ path.find('"') : ] |
|
|
|
path = path[path.find('"'):] |
|
|
|
if 0 <= path.find(', line '): |
|
|
|
path = path.replace(', line ', ':') |
|
|
|
path = path.replace('"', '') |
|
|
|
|
|
|
|
#get line and column numbers |
|
|
|
# get line and column numbers |
|
|
|
line_num = 1 |
|
|
|
column_num = 1 |
|
|
|
line_start = path.find(':', 2) # use 2 here so don't eat Windows full path |
|
|
|
@ -230,22 +232,22 @@ def resolve_path(path): |
|
|
|
if column_end == -1: |
|
|
|
column_end = len(path) |
|
|
|
if 0 <= line_start: |
|
|
|
line_num = path[ line_start + 1 : column_start] |
|
|
|
line_num = path[line_start + 1:column_start] |
|
|
|
if line_num == '': |
|
|
|
line_num = 1 |
|
|
|
if column_start != column_end: |
|
|
|
column_num = path[ column_start + 1 : column_end] |
|
|
|
column_num = path[column_start + 1:column_end] |
|
|
|
if column_num == '': |
|
|
|
column_num = 0 |
|
|
|
|
|
|
|
index_end = path.find(',') |
|
|
|
if 0 <= index_end: |
|
|
|
path = path[ : index_end] # delete comma and anything after |
|
|
|
path = path[:index_end] # delete comma and anything after |
|
|
|
index_end = path.find(':', 2) |
|
|
|
if 0 <= index_end: |
|
|
|
path = path[ : path.find(':', 2)] # delete the line number and anything after |
|
|
|
path = path[:path.find(':', 2)] # delete the line number and anything after |
|
|
|
|
|
|
|
path = path.replace('\\','/') |
|
|
|
path = path.replace('\\', '/') |
|
|
|
|
|
|
|
if 1 == path.find(':') and current_OS == 'Windows': |
|
|
|
return path, line_num, column_num # found a full path - no need for further processing |
|
|
|
@ -258,9 +260,9 @@ def resolve_path(path): |
|
|
|
while 0 <= path.find('../'): |
|
|
|
end = path.find('../') - 1 |
|
|
|
start = path.find('/') |
|
|
|
while 0 <= path.find('/',start) and end > path.find('/',start): |
|
|
|
start = path.find('/',start) + 1 |
|
|
|
path = path[0:start] + path[end + 4: ] |
|
|
|
while 0 <= path.find('/', start) and end > path.find('/', start): |
|
|
|
start = path.find('/', start) + 1 |
|
|
|
path = path[0:start] + path[end + 4:] |
|
|
|
|
|
|
|
# this is an alternative to the above - it just deletes the '../' section |
|
|
|
# start_temp = path.find('../') |
|
|
|
@ -270,11 +272,10 @@ def resolve_path(path): |
|
|
|
# if 0 <= start: |
|
|
|
# path = path[start + 2 : ] |
|
|
|
|
|
|
|
|
|
|
|
start = path.find('/') |
|
|
|
if start != 0: # make sure path starts with '/' |
|
|
|
while 0 == path.find(' '): # eat any spaces at the beginning |
|
|
|
path = path[ 1 : ] |
|
|
|
path = path[1:] |
|
|
|
path = '/' + path |
|
|
|
|
|
|
|
if current_OS == 'Windows': |
|
|
|
@ -291,7 +292,7 @@ def resolve_path(path): |
|
|
|
for filename in filenames: |
|
|
|
if 0 <= root.find('.git'): # don't bother looking in this directory |
|
|
|
break |
|
|
|
full_path = os.path.join(root,filename) |
|
|
|
full_path = os.path.join(root, filename) |
|
|
|
if 0 <= full_path.find(search_path): |
|
|
|
found = True |
|
|
|
break |
|
|
|
@ -304,7 +305,7 @@ def resolve_path(path): |
|
|
|
|
|
|
|
|
|
|
|
# |
|
|
|
# Opens the file in the preferred editor at the line & column number |
|
|
|
# Open the file in the preferred editor at the line & column number |
|
|
|
# If the preferred editor isn't already running then it tries the next. |
|
|
|
# If none are open then the system default is used. |
|
|
|
# |
|
|
|
@ -318,7 +319,7 @@ def open_file(path): |
|
|
|
import subprocess |
|
|
|
file_path, line_num, column_num = resolve_path(path) |
|
|
|
|
|
|
|
if file_path == '' : |
|
|
|
if file_path == '': |
|
|
|
return |
|
|
|
|
|
|
|
if current_OS == 'Windows': |
|
|
|
@ -329,22 +330,22 @@ def open_file(path): |
|
|
|
|
|
|
|
if 0 <= editor_note.find('notepad++.exe'): |
|
|
|
start = editor_note.find('\n') + 1 |
|
|
|
end = editor_note.find('\n',start + 5) -4 |
|
|
|
editor_note = editor_note[ start : end] |
|
|
|
command = file_path , ' -n' + str(line_num) , ' -c' + str(column_num) |
|
|
|
end = editor_note.find('\n', start + 5) - 4 |
|
|
|
editor_note = editor_note[start:end] |
|
|
|
command = file_path, ' -n' + str(line_num), ' -c' + str(column_num) |
|
|
|
subprocess.Popen([editor_note, command]) |
|
|
|
|
|
|
|
elif 0 <= editor_sublime.find('sublime_text.exe'): |
|
|
|
start = editor_sublime.find('\n') + 1 |
|
|
|
end = editor_sublime.find('\n',start + 5) -4 |
|
|
|
editor_sublime = editor_sublime[ start : end] |
|
|
|
end = editor_sublime.find('\n', start + 5) - 4 |
|
|
|
editor_sublime = editor_sublime[start:end] |
|
|
|
command = file_path + ':' + line_num + ':' + column_num |
|
|
|
subprocess.Popen([editor_sublime, command]) |
|
|
|
|
|
|
|
elif 0 <= editor_atom.find('atom.exe'): |
|
|
|
start = editor_atom.find('\n') + 1 |
|
|
|
end = editor_atom.find('\n',start + 5) -4 |
|
|
|
editor_atom = editor_atom[ start : end] |
|
|
|
end = editor_atom.find('\n', start + 5) - 4 |
|
|
|
editor_atom = editor_atom[start:end] |
|
|
|
command = file_path + ':' + str(line_num) + ':' + str(column_num) |
|
|
|
subprocess.Popen([editor_atom, command]) |
|
|
|
|
|
|
|
@ -356,7 +357,7 @@ def open_file(path): |
|
|
|
command = file_path + ':' + str(line_num) + ':' + str(column_num) |
|
|
|
index_end = command.find(',') |
|
|
|
if 0 <= index_end: |
|
|
|
command = command[ : index_end] # sometimes a comma magically appears, don't want it |
|
|
|
command = command[:index_end] # sometimes a comma magically appears, don't want it |
|
|
|
running_apps = subprocess.Popen('ps ax -o cmd', stdout=subprocess.PIPE, shell=True) |
|
|
|
(output, err) = running_apps.communicate() |
|
|
|
temp = output.split('\n') |
|
|
|
@ -366,10 +367,10 @@ def open_file(path): |
|
|
|
if 0 <= line.find(name): |
|
|
|
path = line |
|
|
|
return True, path |
|
|
|
return False , '' |
|
|
|
return False, '' |
|
|
|
|
|
|
|
(success_sublime, editor_path_sublime) = find_editor_linux('sublime_text',temp) |
|
|
|
(success_atom, editor_path_atom) = find_editor_linux('atom',temp) |
|
|
|
(success_sublime, editor_path_sublime) = find_editor_linux('sublime_text', temp) |
|
|
|
(success_atom, editor_path_atom) = find_editor_linux('atom', temp) |
|
|
|
|
|
|
|
if success_sublime: |
|
|
|
subprocess.Popen([editor_path_sublime, command]) |
|
|
|
@ -378,14 +379,14 @@ def open_file(path): |
|
|
|
subprocess.Popen([editor_path_atom, command]) |
|
|
|
|
|
|
|
else: |
|
|
|
os.system('xdg-open ' + file_path ) |
|
|
|
os.system('xdg-open ' + file_path) |
|
|
|
|
|
|
|
elif current_OS == 'Darwin': # MAC |
|
|
|
|
|
|
|
command = file_path + ':' + str(line_num) + ':' + str(column_num) |
|
|
|
index_end = command.find(',') |
|
|
|
if 0 <= index_end: |
|
|
|
command = command[ : index_end] # sometimes a comma magically appears, don't want it |
|
|
|
command = command[:index_end] # sometimes a comma magically appears, don't want it |
|
|
|
running_apps = subprocess.Popen('ps axwww -o command', stdout=subprocess.PIPE, shell=True) |
|
|
|
(output, err) = running_apps.communicate() |
|
|
|
temp = output.split('\n') |
|
|
|
@ -395,12 +396,12 @@ def open_file(path): |
|
|
|
if 0 <= line.find(name): |
|
|
|
path = line |
|
|
|
if 0 <= path.find('-psn'): |
|
|
|
path = path[ : path.find('-psn') - 1 ] |
|
|
|
path = path[:path.find('-psn') - 1] |
|
|
|
return True, path |
|
|
|
return False , '' |
|
|
|
return False, '' |
|
|
|
|
|
|
|
(success_sublime, editor_path_sublime) = find_editor_mac('Sublime',temp) |
|
|
|
(success_atom, editor_path_atom) = find_editor_mac('Atom',temp) |
|
|
|
(success_sublime, editor_path_sublime) = find_editor_mac('Sublime', temp) |
|
|
|
(success_atom, editor_path_atom) = find_editor_mac('Atom', temp) |
|
|
|
|
|
|
|
if success_sublime: |
|
|
|
subprocess.Popen([editor_path_sublime, command]) |
|
|
|
@ -409,11 +410,12 @@ def open_file(path): |
|
|
|
subprocess.Popen([editor_path_atom, command]) |
|
|
|
|
|
|
|
else: |
|
|
|
os.system('open ' + file_path ) |
|
|
|
os.system('open ' + file_path) |
|
|
|
|
|
|
|
# end - open_file |
|
|
|
|
|
|
|
|
|
|
|
# gets the last build environment |
|
|
|
# Get the last build environment |
|
|
|
def get_build_last(): |
|
|
|
env_last = '' |
|
|
|
DIR_PWD = os.listdir('.') |
|
|
|
@ -434,8 +436,8 @@ def get_build_last(): |
|
|
|
return env_last |
|
|
|
|
|
|
|
|
|
|
|
# gets the board being built from the Configuration.h file |
|
|
|
# returns: board name, major version of Marlin being used (1 or 2) |
|
|
|
# Get the board being built from the Configuration.h file |
|
|
|
# return: board name, major version of Marlin being used (1 or 2) |
|
|
|
def get_board_name(): |
|
|
|
board_name = '' |
|
|
|
# get board name |
|
|
|
@ -460,17 +462,16 @@ def get_board_name(): |
|
|
|
define >= 0 : |
|
|
|
spaces = lines.find(' ', board) # find the end of the board substring |
|
|
|
if spaces == -1: |
|
|
|
board_name = lines[board : ] |
|
|
|
board_name = lines[board:] |
|
|
|
else: |
|
|
|
board_name = lines[board : spaces] |
|
|
|
board_name = lines[board:spaces] |
|
|
|
break |
|
|
|
|
|
|
|
|
|
|
|
return board_name, Marlin_ver |
|
|
|
|
|
|
|
|
|
|
|
# extract first environment name it finds after the start position |
|
|
|
# returns: environment name and position to start the next search from |
|
|
|
# extract first environment name found after the start position |
|
|
|
# return: environment name and position to start the next search from |
|
|
|
def get_env_from_line(line, start_position): |
|
|
|
env = '' |
|
|
|
next_position = -1 |
|
|
|
@ -478,14 +479,13 @@ def get_env_from_line(line, start_position): |
|
|
|
if 0 < env_position: |
|
|
|
next_position = line.find(' ', env_position + 4) |
|
|
|
if 0 < next_position: |
|
|
|
env = line[env_position + 4 : next_position] |
|
|
|
env = line[env_position + 4:next_position] |
|
|
|
else: |
|
|
|
env = line[env_position + 4 : ] # at the end of the line |
|
|
|
env = line[env_position + 4:] # at the end of the line |
|
|
|
return env, next_position |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#scans pins.h for board name and returns the environment(s) it finds |
|
|
|
# scan pins.h for board name and return the environment(s) found |
|
|
|
def get_starting_env(board_name_full, version): |
|
|
|
# get environment starting point |
|
|
|
|
|
|
|
@ -500,7 +500,7 @@ def get_starting_env(board_name_full, version): |
|
|
|
env_B = '' |
|
|
|
env_C = '' |
|
|
|
|
|
|
|
board_name = board_name_full[ 6 : ] # only use the part after "BOARD_" since we're searching the pins.h file |
|
|
|
board_name = board_name_full[6:] # only use the part after "BOARD_" since we're searching the pins.h file |
|
|
|
pins_h = pins_h.split('\n') |
|
|
|
environment = '' |
|
|
|
board_line = '' |
|
|
|
@ -530,10 +530,10 @@ def get_starting_env(board_name_full, version): |
|
|
|
return env_A, env_B, env_C |
|
|
|
|
|
|
|
|
|
|
|
# scans input string for CPUs that the users may need to select from |
|
|
|
# returns: CPU name |
|
|
|
# Scan input string for CPUs that users may need to select from |
|
|
|
# return: CPU name |
|
|
|
def get_CPU_name(environment): |
|
|
|
CPU_list = ('1280', '2560','644', '1284', 'LPC1768', 'DUE') |
|
|
|
CPU_list = ('1280', '2560', '644', '1284', 'LPC1768', 'DUE') |
|
|
|
CPU_name = '' |
|
|
|
for CPU in CPU_list: |
|
|
|
if 0 < environment.find(CPU): |
|
|
|
@ -541,8 +541,9 @@ def get_CPU_name(environment): |
|
|
|
|
|
|
|
|
|
|
|
# get environment to be used for the build |
|
|
|
# returns: environment |
|
|
|
# return: environment |
|
|
|
def get_env(board_name, ver_Marlin): |
|
|
|
|
|
|
|
def no_environment(): |
|
|
|
print('ERROR - no environment for this board') |
|
|
|
print(board_name) |
|
|
|
@ -553,11 +554,12 @@ def get_env(board_name, ver_Marlin): |
|
|
|
print(board_name) |
|
|
|
raise SystemExit(0) # quit if unable to find board |
|
|
|
|
|
|
|
CPU_question = (('1280', '2560', '1280 or 2560 CPU?'), ('644', '1284', '644 or 1284 CPU?')) |
|
|
|
|
|
|
|
CPU_question = ( ('1280', '2560', " 1280 or 2560 CPU? "), ('644', '1284', " 644 or 1284 CPU? ") ) |
|
|
|
|
|
|
|
if 0 < board_name.find('MELZI') : |
|
|
|
get_answer(' ' + board_name + ' ', " Which flavor of Melzi? ", "Melzi (Optiboot bootloader)", "Melzi ") |
|
|
|
if 0 < board_name.find('MELZI'): |
|
|
|
get_answer( |
|
|
|
board_name, " Which flavor of Melzi? ", "Melzi (Optiboot bootloader)", "Melzi " |
|
|
|
) |
|
|
|
if 1 == get_answer_val: |
|
|
|
target_env = 'melzi_optiboot' |
|
|
|
else: |
|
|
|
@ -575,7 +577,7 @@ def get_env(board_name, ver_Marlin): |
|
|
|
|
|
|
|
for item in CPU_question: |
|
|
|
if CPU_A == item[0]: |
|
|
|
get_answer(' ' + board_name + ' ', item[2], item[0], item[1]) |
|
|
|
get_answer(board_name, item[2], item[0], item[1]) |
|
|
|
if 2 == get_answer_val: |
|
|
|
target_env = env_B |
|
|
|
else: |
|
|
|
@ -592,11 +594,20 @@ def get_env(board_name, ver_Marlin): |
|
|
|
if build_type == 'traceback' or (build_type == 'clean' and get_build_last() == 'DUE_debug'): |
|
|
|
target_env = 'DUE_debug' |
|
|
|
elif env_B == 'DUE_USB': |
|
|
|
get_answer(' ' + board_name + ' ', " DUE: need download port ", "USB (native USB) port", "Programming port ") |
|
|
|
get_answer(board_name, 'DUE Download Port?', '(Native) USB port', 'Programming port') |
|
|
|
if 1 == get_answer_val: |
|
|
|
target_env = 'DUE_USB' |
|
|
|
else: |
|
|
|
target_env = 'DUE' |
|
|
|
elif env_A == 'STM32F103RC_bigtree': |
|
|
|
get_answer(board_name, 'RCT6 Flash Size?', '512K', '256K') |
|
|
|
if 1 == get_answer_val: |
|
|
|
target_env = 'STM32F103RC_bigtree_512K' |
|
|
|
else: |
|
|
|
target_env = 'STM32F103RC_bigtree' |
|
|
|
get_answer(board_name, 'USB Support?', 'No USB', 'USB') |
|
|
|
if 1 == get_answer_val: |
|
|
|
target_env += '_NOUSB' |
|
|
|
else: |
|
|
|
invalid_board() |
|
|
|
|
|
|
|
@ -607,25 +618,29 @@ def get_env(board_name, ver_Marlin): |
|
|
|
raise SystemExit(0) |
|
|
|
|
|
|
|
return target_env |
|
|
|
|
|
|
|
# end - get_env |
|
|
|
|
|
|
|
|
|
|
|
# puts screen text into queue so that the parent thread can fetch the data from this thread |
|
|
|
if python_ver == 2: |
|
|
|
import Queue as queue |
|
|
|
else: |
|
|
|
import queue as queue |
|
|
|
IO_queue = queue.Queue() |
|
|
|
|
|
|
|
|
|
|
|
#PIO_queue = queue.Queue() not used! |
|
|
|
def write_to_screen_queue(text, format_tag = 'normal'): |
|
|
|
def write_to_screen_queue(text, format_tag='normal'): |
|
|
|
double_in = [text, format_tag] |
|
|
|
IO_queue.put(double_in, block = False) |
|
|
|
IO_queue.put(double_in, block=False) |
|
|
|
|
|
|
|
|
|
|
|
# |
|
|
|
# send one line to the terminal screen with syntax highlighting |
|
|
|
# |
|
|
|
# input: unformatted text, flags from previous run |
|
|
|
# returns: formatted text ready to go to the terminal, flags from this run |
|
|
|
# return: formatted text ready to go to the terminal, flags from this run |
|
|
|
# |
|
|
|
# This routine remembers the status from call to call because previous |
|
|
|
# lines can affect how the current line is highlighted |
|
|
|
@ -641,6 +656,7 @@ next_line_warning = False |
|
|
|
warning_continue = False |
|
|
|
line_counter = 0 |
|
|
|
|
|
|
|
|
|
|
|
def line_print(line_input): |
|
|
|
|
|
|
|
global warning |
|
|
|
@ -654,12 +670,8 @@ def line_print(line_input): |
|
|
|
|
|
|
|
# all '0' elements must precede all '1' elements or they'll be skipped |
|
|
|
platformio_highlights = [ |
|
|
|
['Environment', 0, 'highlight_blue'], |
|
|
|
['[SKIP]', 1, 'warning'], |
|
|
|
['[IGNORED]', 1, 'warning'], |
|
|
|
['[ERROR]', 1, 'error'], |
|
|
|
['[FAILED]', 1, 'error'], |
|
|
|
['[SUCCESS]', 1, 'highlight_green'] |
|
|
|
['Environment', 0, 'highlight_blue'], ['[SKIP]', 1, 'warning'], ['[IGNORED]', 1, 'warning'], ['[ERROR]', 1, 'error'], |
|
|
|
['[FAILED]', 1, 'error'], ['[SUCCESS]', 1, 'highlight_green'] |
|
|
|
] |
|
|
|
|
|
|
|
def write_to_screen_with_replace(text, highlights): # search for highlights & split line accordingly |
|
|
|
@ -668,35 +680,35 @@ def line_print(line_input): |
|
|
|
found = text.find(highlight[0]) |
|
|
|
if did_something == True: |
|
|
|
break |
|
|
|
if found >= 0 : |
|
|
|
if found >= 0: |
|
|
|
did_something = True |
|
|
|
if 0 == highlight[1]: |
|
|
|
found_1 = text.find(' ') |
|
|
|
found_tab = text.find('\t') |
|
|
|
if found_1 < 0 or found_1 > found_tab: |
|
|
|
found_1 = found_tab |
|
|
|
write_to_screen_queue(text[ : found_1 + 1 ]) |
|
|
|
write_to_screen_queue(text[:found_1 + 1]) |
|
|
|
for highlight_2 in highlights: |
|
|
|
if highlight[0] == highlight_2[0] : |
|
|
|
if highlight[0] == highlight_2[0]: |
|
|
|
continue |
|
|
|
found = text.find(highlight_2[0]) |
|
|
|
if found >= 0 : |
|
|
|
if found >= 0: |
|
|
|
found_space = text.find(' ', found_1 + 1) |
|
|
|
found_tab = text.find('\t', found_1 + 1) |
|
|
|
if found_space < 0 or found_space > found_tab: |
|
|
|
found_space = found_tab |
|
|
|
found_right = text.find(']', found + 1) |
|
|
|
write_to_screen_queue(text[found_1 + 1 : found_space + 1 ], highlight[2]) |
|
|
|
write_to_screen_queue(text[found_space + 1 : found + 1 ]) |
|
|
|
write_to_screen_queue(text[found + 1 : found_right], highlight_2[2]) |
|
|
|
write_to_screen_queue(text[found_right : ] + '\n') |
|
|
|
write_to_screen_queue(text[found_1 + 1:found_space + 1], highlight[2]) |
|
|
|
write_to_screen_queue(text[found_space + 1:found + 1]) |
|
|
|
write_to_screen_queue(text[found + 1:found_right], highlight_2[2]) |
|
|
|
write_to_screen_queue(text[found_right:] + '\n') |
|
|
|
break |
|
|
|
break |
|
|
|
if 1 == highlight[1]: |
|
|
|
found_right = text.find(']', found + 1) |
|
|
|
write_to_screen_queue(text[ : found + 1 ]) |
|
|
|
write_to_screen_queue(text[found + 1 : found_right ], highlight[2]) |
|
|
|
write_to_screen_queue(text[found_right : ] + '\n' + '\n') |
|
|
|
write_to_screen_queue(text[:found + 1]) |
|
|
|
write_to_screen_queue(text[found + 1:found_right], highlight[2]) |
|
|
|
write_to_screen_queue(text[found_right:] + '\n' + '\n') |
|
|
|
break |
|
|
|
if did_something == False: |
|
|
|
r_loc = text.find('\r') + 1 |
|
|
|
@ -707,13 +719,13 @@ def line_print(line_input): |
|
|
|
write_to_screen_queue(line + '\n') |
|
|
|
else: |
|
|
|
write_to_screen_queue(text + '\n') |
|
|
|
# end - write_to_screen_with_replace |
|
|
|
|
|
|
|
# end - write_to_screen_with_replace |
|
|
|
|
|
|
|
# scan the line |
|
|
|
# scan the line |
|
|
|
line_counter = line_counter + 1 |
|
|
|
max_search = len(line_input) |
|
|
|
if max_search > 3 : |
|
|
|
if max_search > 3: |
|
|
|
max_search = 3 |
|
|
|
beginning = line_input[:max_search] |
|
|
|
|
|
|
|
@ -726,7 +738,7 @@ def line_print(line_input): |
|
|
|
prev_line_COM = False |
|
|
|
prev_line_COM = False |
|
|
|
warning_continue = True |
|
|
|
if 0 < line_input.find('Thank you') or 0 < line_input.find('SUMMARY') : |
|
|
|
if 0 < line_input.find('Thank you') or 0 < line_input.find('SUMMARY'): |
|
|
|
warning = False #standard line found |
|
|
|
warning_FROM = False |
|
|
|
error = False |
|
|
|
@ -794,13 +806,14 @@ def line_print(line_input): |
|
|
|
if beginning == 'Com': |
|
|
|
prev_line_COM = True |
|
|
|
|
|
|
|
# print based on flags |
|
|
|
# print based on flags |
|
|
|
if standard == True: |
|
|
|
write_to_screen_with_replace(line_input, platformio_highlights) #print white on black with substitutions |
|
|
|
if warning == True: |
|
|
|
write_to_screen_queue(line_input + '\n', 'warning') |
|
|
|
if error == True: |
|
|
|
write_to_screen_queue(line_input + '\n', 'error') |
|
|
|
|
|
|
|
# end - line_print |
|
|
|
|
|
|
|
|
|
|
|
@ -810,7 +823,6 @@ def line_print(line_input): |
|
|
|
# # |
|
|
|
########################################################################## |
|
|
|
|
|
|
|
|
|
|
|
# build platformio run -e target_env |
|
|
|
# clean platformio run --target clean -e target_env |
|
|
|
# upload platformio run --target upload -e target_env |
|
|
|
@ -862,7 +874,6 @@ def sys_PIO(): |
|
|
|
#for line in iter(pio_subprocess.stdout.readline, ''): |
|
|
|
# line_print(line.replace('\n', '')) |
|
|
|
|
|
|
|
|
|
|
|
# append info used to run PlatformIO |
|
|
|
# write_to_screen_queue('\nBoard name: ' + board_name + '\n') # put build info at the bottom of the screen |
|
|
|
# write_to_screen_queue('Build type: ' + build_type + '\n') |
|
|
|
@ -872,7 +883,6 @@ def sys_PIO(): |
|
|
|
# end - sys_PIO |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def run_PIO(dummy): |
|
|
|
|
|
|
|
global build_type |
|
|
|
@ -888,56 +898,66 @@ def run_PIO(dummy): |
|
|
|
if build_type == 'build': |
|
|
|
# platformio run -e target_env |
|
|
|
# combine stdout & stderr so all compile messages are included |
|
|
|
pio_subprocess = subprocess.Popen(['platformio', 'run', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
|
|
|
|
|
|
|
pio_subprocess = subprocess.Popen( |
|
|
|
['platformio', 'run', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT |
|
|
|
) |
|
|
|
|
|
|
|
elif build_type == 'clean': |
|
|
|
# platformio run --target clean -e target_env |
|
|
|
# combine stdout & stderr so all compile messages are included |
|
|
|
pio_subprocess = subprocess.Popen(['platformio', 'run', '--target', 'clean', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
|
|
|
|
|
|
|
pio_subprocess = subprocess.Popen( |
|
|
|
['platformio', 'run', '--target', 'clean', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT |
|
|
|
) |
|
|
|
|
|
|
|
elif build_type == 'upload': |
|
|
|
# platformio run --target upload -e target_env |
|
|
|
# combine stdout & stderr so all compile messages are included |
|
|
|
pio_subprocess = subprocess.Popen(['platformio', 'run', '--target', 'upload', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
|
|
|
|
|
|
|
pio_subprocess = subprocess.Popen( |
|
|
|
['platformio', 'run', '--target', 'upload', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT |
|
|
|
) |
|
|
|
|
|
|
|
elif build_type == 'traceback': |
|
|
|
# platformio run --target upload -e target_env - select the debug environment if there is one |
|
|
|
# combine stdout & stderr so all compile messages are included |
|
|
|
pio_subprocess = subprocess.Popen(['platformio', 'run', '--target', 'upload', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
|
|
|
|
|
|
|
pio_subprocess = subprocess.Popen( |
|
|
|
['platformio', 'run', '--target', 'upload', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT |
|
|
|
) |
|
|
|
|
|
|
|
elif build_type == 'program': |
|
|
|
# platformio run --target program -e target_env |
|
|
|
# combine stdout & stderr so all compile messages are included |
|
|
|
pio_subprocess = subprocess.Popen(['platformio', 'run', '--target', 'program', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
|
|
|
|
|
|
|
pio_subprocess = subprocess.Popen( |
|
|
|
['platformio', 'run', '--target', 'program', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT |
|
|
|
) |
|
|
|
|
|
|
|
elif build_type == 'test': |
|
|
|
#platformio test upload -e target_env |
|
|
|
# combine stdout & stderr so all compile messages are included |
|
|
|
pio_subprocess = subprocess.Popen(['platformio', 'test', 'upload', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
|
|
|
|
|
|
|
pio_subprocess = subprocess.Popen( |
|
|
|
['platformio', 'test', 'upload', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT |
|
|
|
) |
|
|
|
|
|
|
|
elif build_type == 'remote': |
|
|
|
# platformio remote run --target upload -e target_env |
|
|
|
# combine stdout & stderr so all compile messages are included |
|
|
|
pio_subprocess = subprocess.Popen(['platformio', 'remote', 'run', '--target', 'program', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
|
|
|
|
|
|
|
pio_subprocess = subprocess.Popen( |
|
|
|
['platformio', 'remote', 'run', '--target', 'program', '-e', target_env], |
|
|
|
stdout=subprocess.PIPE, |
|
|
|
stderr=subprocess.STDOUT |
|
|
|
) |
|
|
|
|
|
|
|
elif build_type == 'debug': |
|
|
|
# platformio debug -e target_env |
|
|
|
# combine stdout & stderr so all compile messages are included |
|
|
|
pio_subprocess = subprocess.Popen(['platformio', 'debug', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
|
|
|
|
|
|
|
pio_subprocess = subprocess.Popen( |
|
|
|
['platformio', 'debug', '-e', target_env], stdout=subprocess.PIPE, stderr=subprocess.STDOUT |
|
|
|
) |
|
|
|
|
|
|
|
else: |
|
|
|
print('ERROR - unknown build type: ', build_type) |
|
|
|
raise SystemExit(0) # kill everything |
|
|
|
|
|
|
|
# stream output from subprocess and split it into lines |
|
|
|
# stream output from subprocess and split it into lines |
|
|
|
if python_ver == 2: |
|
|
|
for line in iter(pio_subprocess.stdout.readline, ''): |
|
|
|
line_print(line.replace('\n', '')) |
|
|
|
@ -946,7 +966,7 @@ def run_PIO(dummy): |
|
|
|
line = line.decode('utf-8') |
|
|
|
line_print(line.replace('\n', '')) |
|
|
|
|
|
|
|
# append info used to run PlatformIO |
|
|
|
# append info used to run PlatformIO |
|
|
|
write_to_screen_queue('\nBoard name: ' + board_name + '\n') # put build info at the bottom of the screen |
|
|
|
write_to_screen_queue('Build type: ' + build_type + '\n') |
|
|
|
write_to_screen_queue('Environment used: ' + target_env + '\n') |
|
|
|
@ -954,8 +974,6 @@ def run_PIO(dummy): |
|
|
|
|
|
|
|
# end - run_PIO |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
######################################################################## |
|
|
|
|
|
|
|
import time |
|
|
|
@ -970,13 +988,13 @@ if python_ver == 2: |
|
|
|
else: |
|
|
|
import tkinter as tk |
|
|
|
import queue as queue |
|
|
|
from tkinter import ttk, Tk, Frame, Text, Scrollbar, Menu |
|
|
|
from tkinter import filedialog |
|
|
|
from tkinter import ttk, Tk, Frame, Text, Menu |
|
|
|
import subprocess |
|
|
|
import sys |
|
|
|
que = queue.Queue() |
|
|
|
#IO_queue = queue.Queue() |
|
|
|
|
|
|
|
|
|
|
|
class output_window(Text): |
|
|
|
# based on Super Text |
|
|
|
global continue_updates |
|
|
|
@ -988,10 +1006,8 @@ class output_window(Text): |
|
|
|
global error_found |
|
|
|
error_found = False # are there any errors? |
|
|
|
|
|
|
|
|
|
|
|
def __init__(self): |
|
|
|
|
|
|
|
|
|
|
|
self.root = tk.Tk() |
|
|
|
self.root.attributes("-topmost", True) |
|
|
|
self.frame = tk.Frame(self.root) |
|
|
|
@ -1000,22 +1016,22 @@ class output_window(Text): |
|
|
|
# text widget |
|
|
|
#self.text = tk.Text(self.frame, borderwidth=3, relief="sunken") |
|
|
|
Text.__init__(self, self.frame, borderwidth=3, relief="sunken") |
|
|
|
self.config(tabs=(400,)) # configure Text widget tab stops |
|
|
|
self.config(background = 'black', foreground = 'white', font= ("consolas", 12), wrap = 'word', undo = 'True') |
|
|
|
self.config(tabs=(400, )) # configure Text widget tab stops |
|
|
|
self.config(background='black', foreground='white', font=("consolas", 12), wrap='word', undo='True') |
|
|
|
#self.config(background = 'black', foreground = 'white', font= ("consolas", 12), wrap = 'none', undo = 'True') |
|
|
|
self.config(height = 24, width = 100) |
|
|
|
self.config(insertbackground = 'pale green') # keyboard insertion point |
|
|
|
self.config(height=24, width=100) |
|
|
|
self.config(insertbackground='pale green') # keyboard insertion point |
|
|
|
self.pack(side='left', fill='both', expand=True) |
|
|
|
|
|
|
|
self.tag_config('normal', foreground = 'white') |
|
|
|
self.tag_config('warning', foreground = 'yellow' ) |
|
|
|
self.tag_config('error', foreground = 'red') |
|
|
|
self.tag_config('highlight_green', foreground = 'green') |
|
|
|
self.tag_config('highlight_blue', foreground = 'cyan') |
|
|
|
self.tag_config('error_highlight_inactive', background = 'dim gray') |
|
|
|
self.tag_config('error_highlight_active', background = 'light grey') |
|
|
|
self.tag_config('normal', foreground='white') |
|
|
|
self.tag_config('warning', foreground='yellow') |
|
|
|
self.tag_config('error', foreground='red') |
|
|
|
self.tag_config('highlight_green', foreground='green') |
|
|
|
self.tag_config('highlight_blue', foreground='cyan') |
|
|
|
self.tag_config('error_highlight_inactive', background='dim gray') |
|
|
|
self.tag_config('error_highlight_active', background='light grey') |
|
|
|
|
|
|
|
self.bind_class("Text","<Control-a>", self.select_all) # required in windows, works in others |
|
|
|
self.bind_class("Text", "<Control-a>", self.select_all) # required in windows, works in others |
|
|
|
self.bind_all("<Control-Shift-E>", self.scroll_errors) |
|
|
|
self.bind_class("<Control-Shift-R>", self.rebuild) |
|
|
|
|
|
|
|
@ -1044,7 +1060,6 @@ class output_window(Text): |
|
|
|
#self.config(height = 240, width = 1000) # didn't get the size baCK TO NORMAL |
|
|
|
#self.pack(side='left', fill='both', expand=True) # didn't get the size baCK TO NORMAL |
|
|
|
|
|
|
|
|
|
|
|
# pop-up menu |
|
|
|
self.popup = tk.Menu(self, tearoff=0) |
|
|
|
|
|
|
|
@ -1070,47 +1085,42 @@ class output_window(Text): |
|
|
|
else: |
|
|
|
self.bind('<Button-3>', self._show_popup) # Windows & Linux |
|
|
|
|
|
|
|
|
|
|
|
# threading & subprocess section |
|
|
|
# threading & subprocess section |
|
|
|
|
|
|
|
def start_thread(self, ): |
|
|
|
global continue_updates |
|
|
|
# create then start a secondary thread to run an arbitrary function |
|
|
|
# must have at least one argument |
|
|
|
self.secondary_thread = threading.Thread(target = lambda q, arg1: q.put(run_PIO(arg1)), args=(que, '')) |
|
|
|
self.secondary_thread = threading.Thread(target=lambda q, arg1: q.put(run_PIO(arg1)), args=(que, '')) |
|
|
|
self.secondary_thread.start() |
|
|
|
continue_updates = True |
|
|
|
# check the Queue in 50ms |
|
|
|
self.root.after(50, self.check_thread) |
|
|
|
self.root.after(50, self.update) |
|
|
|
|
|
|
|
|
|
|
|
def check_thread(self): # wait for user to kill the window |
|
|
|
global continue_updates |
|
|
|
if continue_updates == True: |
|
|
|
self.root.after(10, self.check_thread) |
|
|
|
|
|
|
|
|
|
|
|
def update(self): |
|
|
|
global continue_updates |
|
|
|
if continue_updates == True: |
|
|
|
self.root.after(10, self.update)#method is called every 50ms |
|
|
|
temp_text = ['0','0'] |
|
|
|
self.root.after(10, self.update) #method is called every 50ms |
|
|
|
temp_text = ['0', '0'] |
|
|
|
if IO_queue.empty(): |
|
|
|
if not(self.secondary_thread.is_alive()): |
|
|
|
if not (self.secondary_thread.is_alive()): |
|
|
|
continue_updates = False # queue is exhausted and thread is dead so no need for further updates |
|
|
|
else: |
|
|
|
try: |
|
|
|
temp_text = IO_queue.get(block = False) |
|
|
|
temp_text = IO_queue.get(block=False) |
|
|
|
except Queue.Empty: |
|
|
|
continue_updates = False # queue is exhausted so no need for further updates |
|
|
|
else: |
|
|
|
self.insert('end', temp_text[0], temp_text[1]) |
|
|
|
self.see("end") # make the last line visible (scroll text off the top) |
|
|
|
|
|
|
|
|
|
|
|
# text editing section |
|
|
|
|
|
|
|
# text editing section |
|
|
|
|
|
|
|
def _scroll_errors(self): |
|
|
|
global search_position |
|
|
|
@ -1137,7 +1147,9 @@ class output_window(Text): |
|
|
|
end_pos = '{}+{}c'.format(search_position, 5) |
|
|
|
start_pos = '{}+{}c'.format(search_position, -1) |
|
|
|
self.tag_remove("error_highlight_active", start_pos, end_pos) |
|
|
|
search_position = self.search("error", search_position, stopindex="end", nocase=1) # finds first occurrence AGAIN on the first time through |
|
|
|
search_position = self.search( |
|
|
|
"error", search_position, stopindex="end", nocase=1 |
|
|
|
) # finds first occurrence AGAIN on the first time through |
|
|
|
if search_position == "": # wrap around |
|
|
|
search_position = self.search("error", '1.0', stopindex="end", nocase=1) |
|
|
|
end_pos = '{}+{}c'.format(search_position, 5) |
|
|
|
@ -1148,7 +1160,6 @@ class output_window(Text): |
|
|
|
def scroll_errors(self, event): |
|
|
|
self._scroll_errors() |
|
|
|
|
|
|
|
|
|
|
|
def _rebuild(self): |
|
|
|
#global board_name |
|
|
|
#global Marlin_ver |
|
|
|
@ -1161,32 +1172,28 @@ class output_window(Text): |
|
|
|
print("event happened") |
|
|
|
self._rebuild() |
|
|
|
|
|
|
|
|
|
|
|
def _open_selected_file(self): |
|
|
|
current_line = self.index('insert') |
|
|
|
line_start = current_line[ : current_line.find('.')] + '.0' |
|
|
|
line_end = current_line[ : current_line.find('.')] + '.200' |
|
|
|
line_start = current_line[:current_line.find('.')] + '.0' |
|
|
|
line_end = current_line[:current_line.find('.')] + '.200' |
|
|
|
self.mark_set("path_start", line_start) |
|
|
|
self.mark_set("path_end", line_end) |
|
|
|
path = self.get("path_start", "path_end") |
|
|
|
from_loc = path.find('from ') |
|
|
|
colon_loc = path.find(': ') |
|
|
|
if 0 <= from_loc and ((colon_loc == -1) or (from_loc < colon_loc)) : |
|
|
|
path = path [ from_loc + 5 : ] |
|
|
|
if 0 <= from_loc and ((colon_loc == -1) or (from_loc < colon_loc)): |
|
|
|
path = path[from_loc + 5:] |
|
|
|
if 0 <= colon_loc: |
|
|
|
path = path [ : colon_loc ] |
|
|
|
path = path[:colon_loc] |
|
|
|
if 0 <= path.find('\\') or 0 <= path.find('/'): # make sure it really contains a path |
|
|
|
open_file(path) |
|
|
|
|
|
|
|
|
|
|
|
def _file_save_as(self): |
|
|
|
self.filename = fileDialog.asksaveasfilename(defaultextension = '.txt') |
|
|
|
self.filename = fileDialog.asksaveasfilename(defaultextension='.txt') |
|
|
|
f = open(self.filename, 'w') |
|
|
|
f.write(self.get('1.0', 'end')) |
|
|
|
f.close() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def copy(self, event): |
|
|
|
try: |
|
|
|
selection = self.get(*self.tag_ranges('sel')) |
|
|
|
@ -1248,11 +1255,9 @@ class output_window(Text): |
|
|
|
def _select_all(self): |
|
|
|
self.tag_add('sel', '1.0', 'end') |
|
|
|
|
|
|
|
|
|
|
|
def select_all(self, event): |
|
|
|
self.tag_add('sel', '1.0', 'end') |
|
|
|
|
|
|
|
|
|
|
|
def _clear_all(self): |
|
|
|
#'''erases all text''' |
|
|
|
# |
|
|
|
@ -1262,14 +1267,11 @@ class output_window(Text): |
|
|
|
# self.delete('1.0', 'end') |
|
|
|
self.delete('1.0', 'end') |
|
|
|
|
|
|
|
|
|
|
|
# end - output_window |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def main(): |
|
|
|
|
|
|
|
|
|
|
|
########################################################################## |
|
|
|
# # |
|
|
|
# main program # |
|
|
|
@ -1294,7 +1296,6 @@ def main(): |
|
|
|
auto_build.root.mainloop() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__': |
|
|
|
|
|
|
|
main() |
|
|
|
|
thisiskeithb
5 years ago
Scott Lahteine