#!/usr/bin/env Python3

import tkinter as tk

from tkinter import filedialog

from tkinter import ttk

import tkinter.scrolledtext as tkst

import tkinter.font

import datetime

import sys

import textwrap

# ----====----====----==== Constants the user CAN safely change ====----====----====----#

DEFAULT_WINDOW_ICON = ''

DEFAULT_ELEMENT_SIZE = (45,1) # In CHARACTERS

DEFAULT_MARGINS = (10,5) # Margins for each LEFT/RIGHT margin is first term

DEFAULT_ELEMENT_PADDING = (5,3) # Padding between elements (row, col) in pixels

DEFAULT_AUTOSIZE_TEXT = True

DEFAULT_AUTOSIZE_BUTTONS = True

DEFAULT_FONT = ("Helvetica", 10)

DEFAULT_TEXT_JUSTIFICATION = 'left'

DEFAULT_BORDER_WIDTH = 1

DEFAULT_AUTOCLOSE_TIME = 3 # time in seconds to show an autoclose form

DEFAULT_DEBUG_WINDOW_SIZE = (80,20)

DEFAULT_WINDOW_LOCATION = (None,None)

MAX_SCROLLED_TEXT_BOX_HEIGHT = 50

#################### COLOR STUFF ####################

BLUES = ("#082567","#0A37A3","#00345B")

PURPLES = ("#480656","#4F2398","#380474")

GREENS = ("#01826B","#40A860","#96D2AB", "#00A949","#003532")

YELLOWS = ("#F3FB62", "#F0F595")

TANS = ("#FFF9D5","#F4EFCF","#DDD8BA")

NICE_BUTTON_COLORS = ((GREENS[3], TANS[0]), ('#000000','#FFFFFF'),('#FFFFFF', '#000000'), (YELLOWS[0], PURPLES[1]),

(YELLOWS[0], GREENS[3]), (YELLOWS[0], BLUES[2]))

COLOR_SYSTEM_DEFAULT = '1234567890' # Colors should never be this long

DEFAULT_BUTTON_COLOR = ('white', BLUES[0]) # Foreground, Background (None, None) == System Default

# DEFAULT_BUTTON_COLOR = COLOR_SYSTEM_DEFAULT # Foreground, Background (None, None) == System Default

DEFAULT_ERROR_BUTTON_COLOR =("#FFFFFF", "#FF0000")

DEFAULT_BACKGROUND_COLOR = None

DEFAULT_ELEMENT_BACKGROUND_COLOR = None

DEFAULT_ELEMENT_TEXT_COLOR = COLOR_SYSTEM_DEFAULT

DEFAULT_TEXT_ELEMENT_BACKGROUND_COLOR = None

DEFAULT_TEXT_COLOR = COLOR_SYSTEM_DEFAULT

DEFAULT_INPUT_ELEMENTS_COLOR = COLOR_SYSTEM_DEFAULT

DEFAULT_INPUT_TEXT_COLOR = COLOR_SYSTEM_DEFAULT

DEFAULT_SCROLLBAR_COLOR = None

# DEFAULT_BUTTON_COLOR = (YELLOWS[0], PURPLES[0]) # (Text, Background) or (Color "on", Color) as a way to remember

# DEFAULT_BUTTON_COLOR = (GREENS[3], TANS[0]) # Foreground, Background (None, None) == System Default

# DEFAULT_BUTTON_COLOR = (YELLOWS[0], GREENS[4]) # Foreground, Background (None, None) == System Default

# DEFAULT_BUTTON_COLOR = ('white', 'black') # Foreground, Background (None, None) == System Default

# DEFAULT_BUTTON_COLOR = (YELLOWS[0], PURPLES[2]) # Foreground, Background (None, None) == System Default

# DEFAULT_PROGRESS_BAR_COLOR = (GREENS[2], GREENS[0]) # a nice green progress bar

# DEFAULT_PROGRESS_BAR_COLOR = (BLUES[1], BLUES[1]) # a nice green progress bar

# DEFAULT_PROGRESS_BAR_COLOR = (BLUES[0], BLUES[0]) # a nice green progress bar

# DEFAULT_PROGRESS_BAR_COLOR = (PURPLES[1],PURPLES[0]) # a nice purple progress bar

# A transparent button is simply one that matches the background

TRANSPARENT_BUTTON = ('#F0F0F0', '#F0F0F0')

#--------------------------------------------------------------------------------

# Progress Bar Relief Choices

RELIEF_RAISED= 'raised'

RELIEF_SUNKEN= 'sunken'

RELIEF_FLAT= 'flat'

RELIEF_RIDGE= 'ridge'

RELIEF_GROOVE= 'groove'

RELIEF_SOLID = 'solid'

DEFAULT_PROGRESS_BAR_COLOR = (GREENS[0], '#D0D0D0') # a nice green progress bar

DEFAULT_PROGRESS_BAR_SIZE = (25,20) # Size of Progress Bar (characters for length, pixels for width)

DEFAULT_PROGRESS_BAR_BORDER_WIDTH=1

DEFAULT_PROGRESS_BAR_RELIEF = RELIEF_GROOVE

PROGRESS_BAR_STYLES = ('default','winnative', 'clam', 'alt', 'classic', 'vista', 'xpnative')

DEFAULT_PROGRESS_BAR_STYLE = 'default'

DEFAULT_METER_ORIENTATION = 'Horizontal'

DEFAULT_SLIDER_ORIENTATION = 'vertical'

DEFAULT_SLIDER_BORDER_WIDTH=1

DEFAULT_SLIDER_RELIEF = tk.FLAT

DEFAULT_LISTBOX_SELECT_MODE = tk.SINGLE

SELECT_MODE_MULTIPLE = tk.MULTIPLE

LISTBOX_SELECT_MODE_MULTIPLE = 'multiple'

SELECT_MODE_BROWSE = tk.BROWSE

LISTBOX_SELECT_MODE_BROWSE = 'browse'

SELECT_MODE_EXTENDED = tk.EXTENDED

LISTBOX_SELECT_MODE_EXTENDED = 'extended'

SELECT_MODE_SINGLE = tk.SINGLE

LISTBOX_SELECT_MODE_SINGLE = 'single'

# DEFAULT_METER_ORIENTATION = 'Vertical'

# ----====----====----==== Constants the user should NOT f-with ====----====----====----#

ThisRow = 555666777 # magic number

# DEFAULT_WINDOW_ICON = ''

MESSAGE_BOX_LINE_WIDTH = 60

# a shameful global variable. This represents the top-level window information. Needed because opening a second window is different than opening the first.

class MyWindows():

def __init__(self):

self.NumOpenWindows = 0

self.user_defined_icon = None

def Decrement(self):

self.NumOpenWindows -= 1 * (self.NumOpenWindows != 0) # decrement if not 0

# print('---- DECREMENTING Num Open Windows = {} ---'.format(self.NumOpenWindows))

def Increment(self):

self.NumOpenWindows += 1

# print('++++ INCREMENTING Num Open Windows = {} ++++'.format(self.NumOpenWindows))

_my_windows = MyWindows() # terrible hack using globals... means need a class for collecing windows

# ====================================================================== #

# One-liner functions that are handy as f_ck #

# ====================================================================== #

def RGB(red,green,blue): return '#%02x%02x%02x' % (red,green,blue)

# ====================================================================== #

# Enums for types #

# ====================================================================== #

# ------------------------- Button types ------------------------- #

#todo Consider removing the Submit, Cancel types... they are just 'RETURN' type in reality

#uncomment this line and indent to go back to using Enums

# class ButtonType(Enum):

BUTTON_TYPE_BROWSE_FOLDER = 1

BUTTON_TYPE_BROWSE_FILE = 2

BUTTON_TYPE_SAVEAS_FILE = 3

BUTTON_TYPE_CLOSES_WIN = 5

BUTTON_TYPE_READ_FORM = 7

BUTTON_TYPE_REALTIME = 9

# ------------------------- Element types ------------------------- #

# class ElementType(Enum):

ELEM_TYPE_TEXT = 1

ELEM_TYPE_INPUT_TEXT = 20

ELEM_TYPE_INPUT_COMBO = 21

ELEM_TYPE_INPUT_RADIO = 5

ELEM_TYPE_INPUT_MULTILINE = 7

ELEM_TYPE_INPUT_CHECKBOX = 8

ELEM_TYPE_INPUT_SPIN = 9

ELEM_TYPE_BUTTON = 3

ELEM_TYPE_IMAGE = 30

ELEM_TYPE_INPUT_SLIDER = 10

ELEM_TYPE_INPUT_LISTBOX = 11

ELEM_TYPE_OUTPUT = 300

ELEM_TYPE_COLUMN = 555

ELEM_TYPE_PROGRESS_BAR = 200

ELEM_TYPE_BLANK = 100

# ------------------------- MsgBox Buttons Types ------------------------- #

MSG_BOX_YES_NO = 1

MSG_BOX_CANCELLED = 2

MSG_BOX_ERROR = 3

MSG_BOX_OK_CANCEL = 4

MSG_BOX_OK = 0

# ---------------------------------------------------------------------- #

# Cascading structure.... Objects get larger #

# Button #

# Element #

# Row #

# Form #

# ---------------------------------------------------------------------- #

# ------------------------------------------------------------------------- #

# Element CLASS #

# ------------------------------------------------------------------------- #

class Element():

def __init__(self, type, scale=(None, None), size=(None, None), auto_size_text=None, font=None, background_color=None, text_color=None, key=None, pad=None):

self.Size = size

self.Type = type

self.AutoSizeText = auto_size_text

self.Scale = scale

self.Pad = DEFAULT_ELEMENT_PADDING if pad is None else pad

self.Font = font

self.TKStringVar = None

self.TKIntVar = None

self.TKText = None

self.TKEntry = None

self.TKImage = None

self.ParentForm=None

self.TextInputDefault = None

self.Position = (0,0) # Default position Row 0, Col 0

self.BackgroundColor = background_color if background_color is not None else DEFAULT_ELEMENT_BACKGROUND_COLOR

self.TextColor = text_color if text_color is not None else DEFAULT_ELEMENT_TEXT_COLOR

self.Key = key # dictionary key for return values

def ReturnKeyHandler(self, event):

MyForm = self.ParentForm

# search through this form and find the first button that will exit the form

for row in MyForm.Rows:

for element in row:

if element.Type == ELEM_TYPE_BUTTON:

if element.BindReturnKey:

element.ButtonCallBack()

def __del__(self):

try:

self.TKStringVar.__del__()

except:

pass

try:

self.TKIntVar.__del__()

except:

pass

try:

self.TKText.__del__()

except:

pass

try:

self.TKEntry.__del__()

except:

pass

# ---------------------------------------------------------------------- #

# Input Class #

# ---------------------------------------------------------------------- #

class InputText(Element):

def __init__(self, default_text ='', scale=(None, None), size=(None, None), auto_size_text=None, password_char='', background_color=None, text_color=None, do_not_clear=False, key=None, focus=False, pad=None):

'''

Input a line of text Element

:param default_text: Default value to display

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

:param auto_size_text: True if should shrink field to fit the default text

:param password_char: If non-blank, will display this character for every character typed

:param background_color: Color for Element. Text or RGB Hex

'''

self.DefaultText = default_text

self.PasswordCharacter = password_char

bg = background_color if background_color is not None else DEFAULT_INPUT_ELEMENTS_COLOR

fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR

self.Focus = focus

self.do_not_clear = do_not_clear

super().__init__(ELEM_TYPE_INPUT_TEXT, scale=scale, size=size, auto_size_text=auto_size_text, background_color=bg, text_color=fg, key=key, pad=pad)

def Update(self, new_value):

self.TKStringVar.set(new_value)

def Get(self):

return self.TKStringVar.get()

def __del__(self):

super().__del__()

# ---------------------------------------------------------------------- #

# Combo #

# ---------------------------------------------------------------------- #

class InputCombo(Element):

def __init__(self, values, scale=(None, None), size=(None, None), auto_size_text=None, background_color=None, text_color=None, key=None, pad=None):

'''

Input Combo Box Element (also called Dropdown box)

:param values:

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

:param auto_size_text: True if should shrink field to fit the default text

:param background_color: Color for Element. Text or RGB Hex

'''

self.Values = values

self.TKComboBox = None

bg = background_color if background_color else DEFAULT_INPUT_ELEMENTS_COLOR

fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR

super().__init__(ELEM_TYPE_INPUT_COMBO, scale=scale, size=size, auto_size_text=auto_size_text, background_color=bg, text_color=fg, key=key, pad=pad)

def __del__(self):

try:

self.TKComboBox.__del__()

except:

pass

super().__del__()

# ---------------------------------------------------------------------- #

# Listbox #

# ---------------------------------------------------------------------- #

class Listbox(Element):

def __init__(self, values, select_mode=None, scale=(None, None), size=(None, None), auto_size_text=None, font=None, background_color=None, text_color=None, key=None, pad=None):

'''

Listbox Element

:param values:

:param select_mode: SELECT_MODE_BROWSE, SELECT_MODE_EXTENDED, SELECT_MODE_MULTIPLE, SELECT_MODE_SINGLE

:param font:

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

:param auto_size_text: True if should shrink field to fit the default text

:param background_color: Color for Element. Text or RGB Hex '''

self.Values = values

self.TKListbox = None

if select_mode == LISTBOX_SELECT_MODE_BROWSE:

self.SelectMode = SELECT_MODE_BROWSE

elif select_mode == LISTBOX_SELECT_MODE_EXTENDED:

self.SelectMode = SELECT_MODE_EXTENDED

elif select_mode == LISTBOX_SELECT_MODE_MULTIPLE:

self.SelectMode = SELECT_MODE_MULTIPLE

elif select_mode == LISTBOX_SELECT_MODE_SINGLE:

self.SelectMode = SELECT_MODE_SINGLE

else:

self.SelectMode = DEFAULT_LISTBOX_SELECT_MODE

bg = background_color if background_color else DEFAULT_INPUT_ELEMENTS_COLOR

fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR

super().__init__(ELEM_TYPE_INPUT_LISTBOX, scale=scale, size=size, auto_size_text=auto_size_text, font=font, background_color=bg, text_color=fg, key=key, pad=pad)

def Update(self, values):

self.TKListbox.delete(0, 'end')

for item in values:

self.TKListbox.insert(tk.END, item)

self.TKListbox.selection_set(0, 0)

def __del__(self):

try:

self.TKListBox.__del__()

except:

pass

super().__del__()

# ---------------------------------------------------------------------- #

# Radio #

# ---------------------------------------------------------------------- #

class Radio(Element):

def __init__(self, text, group_id, default=False, scale=(None, None), size=(None, None), auto_size_text=None, background_color=None, text_color=None, font=None, key=None, pad=None):

'''

Radio Button Element

:param text:

:param group_id:

:param default:

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

:param auto_size_text: True if should shrink field to fit the default text

:param background_color: Color for Element. Text or RGB Hex

:param font:

'''

self.InitialState = default

self.Text = text

self.TKRadio = None

self.GroupID = group_id

self.Value = None

super().__init__(ELEM_TYPE_INPUT_RADIO, scale=scale , size=size, auto_size_text=auto_size_text, font=font, background_color=background_color, text_color=text_color, key=key, pad=pad)

def __del__(self):

try:

self.TKRadio.__del__()

except:

pass

super().__del__()

# ---------------------------------------------------------------------- #

# Checkbox #

# ---------------------------------------------------------------------- #

class Checkbox(Element):

def __init__(self, text, default=False, scale=(None, None), size=(None, None), auto_size_text=None, font=None, background_color=None, text_color=None, key=None, pad=None):

'''

Check Box Element

:param text:

:param default:

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

:param auto_size_text: True if should shrink field to fit the default text

:param background_color: Color for Element. Text or RGB Hex

:param font:

'''

self.Text = text

self.InitialState = default

self.Value = None

self.TKCheckbutton = None

super().__init__(ELEM_TYPE_INPUT_CHECKBOX, scale=scale, size=size, auto_size_text=auto_size_text, font=font, background_color=background_color, text_color=text_color, key=key, pad=pad)

def Get(self):

return self.TKIntVar.get()

def Update(self, value):

if value is None:

self.TKCheckbutton.configure(state='disabled')

else:

self.TKCheckbutton.configure(state='normal')

self.TKIntVar.set(value)

def __del__(self):

super().__del__()

# ---------------------------------------------------------------------- #

# Spin #

# ---------------------------------------------------------------------- #

class Spin(Element):

# Values = None

# TKSpinBox = None

def __init__(self, values, initial_value=None, scale=(None, None), size=(None, None), auto_size_text=None, font=None, background_color=None, text_color=None, key=None, pad=None):

'''

Spin Box Element

:param values:

:param initial_value:

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

:param auto_size_text: True if should shrink field to fit the default text

:param background_color: Color for Element. Text or RGB Hex

:param font:

'''

self.Values = values

self.DefaultValue = initial_value

self.TKSpinBox = None

bg = background_color if background_color else DEFAULT_INPUT_ELEMENTS_COLOR

fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR

super().__init__(ELEM_TYPE_INPUT_SPIN, scale, size, auto_size_text, font=font,background_color=bg, text_color=fg, key=key, pad=pad)

return

def __del__(self):

try:

self.TKSpinBox.__del__()

except:

pass

super().__del__()

# ---------------------------------------------------------------------- #

# Multiline #

# ---------------------------------------------------------------------- #

class Multiline(Element):

def __init__(self, default_text='', enter_submits = False, scale=(None, None), size=(None, None), auto_size_text=None, background_color=None, text_color=None, do_not_clear=False, key=None, focus=False, pad=None):

'''

Input Multi-line Element

:param default_text:

:param enter_submits:

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

:param auto_size_text: True if should shrink field to fit the default text

:param background_color: Color for Element. Text or RGB Hex

'''

self.DefaultText = default_text

self.EnterSubmits = enter_submits

bg = background_color if background_color else DEFAULT_INPUT_ELEMENTS_COLOR

self.Focus = focus

self.do_not_clear = do_not_clear

fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR

super().__init__(ELEM_TYPE_INPUT_MULTILINE, scale=scale, size=size, auto_size_text=auto_size_text, background_color=bg, text_color=fg, key=key, pad=pad)

return

def Update(self, NewValue):

self.TKText.insert(1.0, NewValue)

def Get(self):

return self.TKText.get(1.0, tk.END)

def __del__(self):

super().__del__()

# ---------------------------------------------------------------------- #

# Text #

# ---------------------------------------------------------------------- #

class Text(Element):

def __init__(self, text, scale=(None, None), size=(None, None), auto_size_text=None, font=None, text_color=None, background_color=None,justification=None, pad=None):

'''

Text Element - Displays text in your form. Can be updated in non-blocking forms

:param text: The text to display

:param scale: Scaling factor (w,h) (2,2)= 2 * Size

:param size: Size of Element in Characters

:param auto_size_text: True if the field should shrink to fit the text

:param font: Font name and size ("name", size)

:param text_color: Text Color name or RGB hex value '#RRGGBB'

:param background_color: Background color for text (name or RGB Hex)

:param justification: 'left', 'right', 'center'

'''

self.DisplayText = text

self.TextColor = text_color if text_color else DEFAULT_TEXT_COLOR

self.Justification = justification

if background_color is None:

bg = DEFAULT_TEXT_ELEMENT_BACKGROUND_COLOR

else:

bg = background_color

super().__init__(ELEM_TYPE_TEXT, scale, size, auto_size_text, background_color=bg, font=font if font else DEFAULT_FONT, text_color=self.TextColor, pad=pad)

return

def Update(self, new_value = None, background_color=None, text_color=None):

if new_value is not None:

self.DisplayText=new_value

stringvar = self.TKStringVar

stringvar.set(new_value)

if background_color is not None:

self.TKText.configure(background=background_color)

if text_color is not None:

self.TKText.configure(fg=text_color)

def __del__(self):

super().__del__()

# ---------------------------------------------------------------------- #

# TKProgressBar #

# Emulate the TK ProgressBar using canvas and rectangles

# ---------------------------------------------------------------------- #

class TKProgressBar():

def __init__(self, root, max, length=400, width=DEFAULT_PROGRESS_BAR_SIZE[1], style=DEFAULT_PROGRESS_BAR_STYLE, relief=DEFAULT_PROGRESS_BAR_RELIEF, border_width=DEFAULT_PROGRESS_BAR_BORDER_WIDTH, orientation='horizontal', BarColor=(None,None)):

self.Length = length

self.Width = width

self.Max = max

self.Orientation = orientation

self.Count = None

self.PriorCount = 0

if orientation[0].lower() == 'h':

s = ttk.Style()

s.theme_use(style)

s.configure(str(length)+str(width)+"my.Horizontal.TProgressbar", background=BarColor[0], troughcolor=BarColor[1], troughrelief=relief, borderwidth=border_width, thickness=width)

self.TKProgressBarForReal = ttk.Progressbar(root, maximum=self.Max, style=str(length)+str(width)+'my.Horizontal.TProgressbar', length=length, orient=tk.HORIZONTAL, mode='determinate')

else:

s = ttk.Style()

s.theme_use(style)

s.configure(str(length)+str(width)+"my.Vertical.TProgressbar", background=BarColor[0], troughcolor=BarColor[1], troughrelief=relief, borderwidth=border_width, thickness=width)

self.TKProgressBarForReal = ttk.Progressbar(root, maximum=self.Max, style=str(length)+str(width)+'my.Vertical.TProgressbar', length=length, orient=tk.VERTICAL, mode='determinate')

def Update(self, count, max=None):

if max is not None:

self.Max = max

try:

self.TKProgressBarForReal.config(maximum=max)

except:

return False

if count > self.Max: return False

try:

self.TKProgressBarForReal['value'] = count

except: return False

return True

def __del__(self):

try:

self.TKProgressBarForReal.__del__()

except:

pass

# ---------------------------------------------------------------------- #

# TKOutput #

# New Type of TK Widget that's a Text Widget in disguise #

# Note that it's inherited from the TKFrame class so that the #

# Scroll bar will span the length of the frame #

# ---------------------------------------------------------------------- #

class TKOutput(tk.Frame):

def __init__(self, parent, width, height, bd, background_color=None, text_color=None):

frame = tk.Frame(parent, width=width, height=height)

tk.Frame.__init__(self, frame)

self.output = tk.Text(frame, width=width, height=height, bd=bd)

if background_color and background_color != COLOR_SYSTEM_DEFAULT:

self.output.configure(background=background_color)

if text_color and text_color != COLOR_SYSTEM_DEFAULT:

self.output.configure(fg=text_color)

self.vsb = tk.Scrollbar(frame, orient="vertical", command=self.output.yview)

self.output.configure(yscrollcommand=self.vsb.set)

self.output.pack(side="left", fill="both")

self.vsb.pack(side="left", fill="y")

frame.pack(side="left")

self.previous_stdout = sys.stdout

self.previous_stderr = sys.stderr

sys.stdout = self

sys.stderr = self

self.pack()

def write(self, txt):

try:

self.output.insert(tk.END, str(txt))

self.output.see(tk.END)

except:

pass

def Close(self):

sys.stdout = self.previous_stdout

sys.stderr = self.previous_stderr

def flush(self):

sys.stdout = self.previous_stdout

sys.stderr = self.previous_stderr

def __del__(self):

sys.stdout = self.previous_stdout

sys.stderr = self.previous_stderr

# ---------------------------------------------------------------------- #

# Output #

# Routes stdout, stderr to a scrolled window #

# ---------------------------------------------------------------------- #

class Output(Element):

def __init__(self, scale=(None, None), size=(None, None), background_color=None, text_color=None, pad=None):

'''

Output Element - reroutes stdout, stderr to this window

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

:param background_color: Color for Element. Text or RGB Hex

'''

self.TKOut = None

bg = background_color if background_color else DEFAULT_INPUT_ELEMENTS_COLOR

fg = text_color if text_color is not None else DEFAULT_INPUT_TEXT_COLOR

super().__init__(ELEM_TYPE_OUTPUT, scale=scale, size=size, background_color=bg, text_color=fg, pad=pad)

def __del__(self):

try:

self.TKOut.__del__()

except:

pass

super().__del__()

# ---------------------------------------------------------------------- #

# Button Class #

# ---------------------------------------------------------------------- #

class Button(Element):

def __init__(self, button_type=BUTTON_TYPE_CLOSES_WIN, target=(None, None), button_text='', file_types=(("ALL Files", "*.*"),), image_filename=None, image_size=(None, None), image_subsample=None, border_width=None, scale=(None, None), size=(None, None), auto_size_button=None, button_color=None, font=None, bind_return_key=False, focus=False, pad=None):

'''

Button Element - Specifies all types of buttons

:param button_type:

:param target:

:param button_text:

:param file_types:

:param image_filename:

:param image_size:

:param image_subsample:

:param border_width:

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

:param auto_size_button:

:param button_color:

:param font:

'''

self.AutoSizeButton = auto_size_button

self.BType = button_type

self.FileTypes = file_types

self.TKButton = None

self.Target = target

self.ButtonText = button_text

self.ButtonColor = button_color if button_color else DEFAULT_BUTTON_COLOR

self.ImageFilename = image_filename

self.ImageSize = image_size

self.ImageSubsample = image_subsample

self.UserData = None

self.BorderWidth = border_width if border_width is not None else DEFAULT_BORDER_WIDTH

self.BindReturnKey = bind_return_key

self.Focus = focus

super().__init__(ELEM_TYPE_BUTTON, scale=scale, size=size, font=font, pad=pad)

return

def ButtonReleaseCallBack(self, parm):

r, c = self.Position

self.ParentForm.LastButtonClicked = None

def ButtonPressCallBack(self, parm):

r, c = self.Position

self.ParentForm.LastButtonClicked = self.ButtonText

# ------- Button Callback ------- #

def ButtonCallBack(self):

global _my_windows

# Buttons modify targets or return from the form

# If modifying target, get the element object at the target and modify its StrVar

target = self.Target

if target[0] == ThisRow:

target = [self.Position[0], target[1]]

if target[1] < 0:

target[1] = self.Position[1] + target[1]

strvar = None

if target[0] != None:

if target[0] < 0:

target = [self.Position[0] + target[0], target[1]]

target_element = self.ParentForm.GetElementAtLocation(target)

try:

strvar = target_element.TKStringVar

except: pass

else:

strvar = None

filetypes = [] if self.FileTypes is None else self.FileTypes

if self.BType == BUTTON_TYPE_BROWSE_FOLDER:

folder_name = tk.filedialog.askdirectory() # show the 'get folder' dialog box

try:

strvar.set(folder_name)

except: pass

elif self.BType == BUTTON_TYPE_BROWSE_FILE:

file_name = tk.filedialog.askopenfilename(filetypes=filetypes) # show the 'get file' dialog box

strvar.set(file_name)

elif self.BType == BUTTON_TYPE_SAVEAS_FILE:

file_name = tk.filedialog.asksaveasfilename(filetypes=filetypes) # show the 'get file' dialog box

strvar.set(file_name)

elif self.BType == BUTTON_TYPE_CLOSES_WIN: # this is a return type button so GET RESULTS and destroy window

# first, get the results table built

# modify the Results table in the parent FlexForm object

r,c = self.Position

self.ParentForm.LastButtonClicked = self.ButtonText

self.ParentForm.FormRemainedOpen = False

# if the form is tabbed, must collect all form's results and destroy all forms

if self.ParentForm.IsTabbedForm:

self.ParentForm.UberParent._Close()

else:

self.ParentForm._Close()

self.ParentForm.TKroot.quit()

if self.ParentForm.NonBlocking:

self.ParentForm.TKroot.destroy()

_my_windows.Decrement()

elif self.BType == BUTTON_TYPE_READ_FORM: # LEAVE THE WINDOW OPEN!! DO NOT CLOSE

# first, get the results table built

# modify the Results table in the parent FlexForm object

r,c = self.Position

self.ParentForm.LastButtonClicked = self.ButtonText

self.ParentForm.FormRemainedOpen = True

self.ParentForm.TKroot.quit() # kick the users out of the mainloop

return

def Update(self, new_text, button_color=(None, None)):

try:

self.TKButton.configure(text=new_text)

if button_color != (None, None):

self.TKButton.config(foreground=button_color[0], background=button_color[1])

except:

return

def __del__(self):

try:

self.TKButton.__del__()

except:

pass

super().__del__()

# ---------------------------------------------------------------------- #

# ProgreessBar #

# ---------------------------------------------------------------------- #

class ProgressBar(Element):

def __init__(self, max_value, orientation=None, scale=(None, None), size=(None, None), auto_size_text=None, bar_color=(None, None), style=None, border_width=None, relief=None, pad=None):

'''

Progress Bar Element

:param max_value:

:param orientation:

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

:param auto_size_text: True if should shrink field to fit the default text

:param bar_color:

:param style:

:param border_width:

:param relief:

'''

self.MaxValue = max_value

self.TKProgressBar = None

self.Cancelled = False

self.NotRunning = True

self.Orientation = orientation if orientation else DEFAULT_METER_ORIENTATION

self.BarColor = bar_color

self.BarStyle = style if style else DEFAULT_PROGRESS_BAR_STYLE

self.BorderWidth = border_width if border_width else DEFAULT_PROGRESS_BAR_BORDER_WIDTH

self.Relief = relief if relief else DEFAULT_PROGRESS_BAR_RELIEF

self.BarExpired = False

super().__init__(ELEM_TYPE_PROGRESS_BAR, scale=scale, size=size, auto_size_text=auto_size_text, pad=pad)

return

def UpdateBar(self, current_count, max=None):

if self.ParentForm.TKrootDestroyed:

return False

self.TKProgressBar.Update(current_count, max=max)

try:

self.ParentForm.TKroot.update()

except:

_my_windows.Decrement()

return False

return True

def __del__(self):

try:

self.TKProgressBar.__del__()

except:

pass

super().__del__()

# ---------------------------------------------------------------------- #

# Image #

# ---------------------------------------------------------------------- #

class Image(Element):

def __init__(self, filename=None, data=None,scale=(None, None), size=(None, None), pad=None):

'''

Image Element

:param filename:

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

'''

self.Filename = filename

self.Data = data

self.tktext_label = None

if data is None and filename is None:

print('* Warning... no image specified in Image Element! *')

super().__init__(ELEM_TYPE_IMAGE, scale=scale, size=size, pad=pad)

return

def Update(self, filename=None, data=None):

if filename is not None:

image = tk.PhotoImage(file=filename)

elif data is not None:

if type(data) is bytes:

image = tk.PhotoImage(data=data)

else:

image = data

else: return

width, height = image.width(), image.height()

self.tktext_label.configure(image=image, width=width, height=height)

self.tktext_label.image = image

def __del__(self):

super().__del__()

# ---------------------------------------------------------------------- #

# Slider #

# ---------------------------------------------------------------------- #

class Slider(Element):

def __init__(self, range=(None,None), default_value=None, orientation=None, border_width=None, relief=None, scale=(None, None), size=(None, None), font=None, background_color=None, text_color=None, key=None, pad=None):

'''

Slider Element

:param range:

:param default_value:

:param orientation:

:param border_width:

:param relief:

:param scale: Adds multiplier to size (w,h)

:param size: Size of field in characters

:param background_color: Color for Element. Text or RGB Hex

:param font:

'''

self.TKScale = None

self.Range = (1,10) if range == (None, None) else range

self.DefaultValue = 5 if default_value is None else default_value

self.Orientation = orientation if orientation else DEFAULT_SLIDER_ORIENTATION

self.BorderWidth = border_width if border_width else DEFAULT_SLIDER_BORDER_WIDTH

self.Relief = relief if relief else DEFAULT_SLIDER_RELIEF

super().__init__(ELEM_TYPE_INPUT_SLIDER, scale=scale, size=size, font=font, background_color=background_color, text_color=text_color, key=key, pad=pad)

return

def Update(self, value, range=(None, None)):

self.TKIntVar.set(value)

if range != (None, None):

self.TKScale.config(from_ = range[0], to_ = range[1])

def __del__(self):

super().__del__()

# ---------------------------------------------------------------------- #

# Column #

# ---------------------------------------------------------------------- #

class Column(Element):

def __init__(self, layout, background_color = None, pad=None):

self.UseDictionary = False

self.ReturnValues = None

self.ReturnValuesList = []

self.ReturnValuesDictionary = {}

self.DictionaryKeyCounter = 0

self.ParentWindow = None

self.Rows = []

self.ParentForm = None

self.TKFrame = None

bg = background_color if background_color is not None else DEFAULT_BACKGROUND_COLOR

self.Layout(layout)

super().__init__(ELEM_TYPE_COLUMN, background_color=background_color, pad=pad)

return

def AddRow(self, *args):

''' Parms are a variable number of Elements '''

NumRows = len(self.Rows) # number of existing rows is our row number

CurrentRowNumber = NumRows # this row's number

CurrentRow = [] # start with a blank row and build up

# ------------------------- Add the elements to a row ------------------------- #

for i, element in enumerate(args): # Loop through list of elements and add them to the row

element.Position = (CurrentRowNumber, i)

CurrentRow.append(element)

if element.Key is not None:

self.UseDictionary = True

# ------------------------- Append the row to list of Rows ------------------------- #

self.Rows.append(CurrentRow)

def Layout(self, rows):

for row in rows:

self.AddRow(*row)

def __del__(self):

for row in self.Rows:

for element in row:

element.__del__()

try:

del(self.TKFrame)

except:

pass

super().__del__()

# ------------------------------------------------------------------------- #

# FlexForm CLASS #

# ------------------------------------------------------------------------- #

class FlexForm:

'''

Display a user defined for and return the filled in data

'''

def __init__(self, title, default_element_size=(DEFAULT_ELEMENT_SIZE[0], DEFAULT_ELEMENT_SIZE[1]), auto_size_text=None, auto_size_buttons=None, scale=(None, None), location=(None, None), button_color=None, font=None, progress_bar_color=(None, None), background_color=None, is_tabbed_form=False, border_depth=None, auto_close=False, auto_close_duration=DEFAULT_AUTOCLOSE_TIME, icon=DEFAULT_WINDOW_ICON, return_keyboard_events=False, use_default_focus=True, text_justification=None):

self.AutoSizeText = auto_size_text if auto_size_text is not None else DEFAULT_AUTOSIZE_TEXT

self.AutoSizeButtons = auto_size_buttons if auto_size_buttons is not None else DEFAULT_AUTOSIZE_BUTTONS

self.Title = title

self.Rows = [] # a list of ELEMENTS for this row

self.DefaultElementSize = default_element_size

self.Scale = scale

self.Location = location

self.ButtonColor = button_color if button_color else DEFAULT_BUTTON_COLOR

self.BackgroundColor = background_color if background_color else DEFAULT_BACKGROUND_COLOR

self.IsTabbedForm = is_tabbed_form

self.ParentWindow = None

self.Font = font if font else DEFAULT_FONT

self.RadioDict = {}

self.BorderDepth = border_depth

self.WindowIcon = icon if not _my_windows.user_defined_icon else _my_windows.user_defined_icon

self.AutoClose = auto_close

self.NonBlocking = False

self.TKroot = None

self.TKrootDestroyed = False

self.FormRemainedOpen = False

self.TKAfterID = None

self.ProgressBarColor = progress_bar_color

self.AutoCloseDuration = auto_close_duration

self.UberParent = None

self.RootNeedsDestroying = False

self.Shown = False

self.ReturnValues = None

self.ReturnValuesList = []

self.ReturnValuesDictionary = {}

self.DictionaryKeyCounter = 0

self.LastButtonClicked = None

self.UseDictionary = False

self.UseDefaultFocus = use_default_focus

self.ReturnKeyboardEvents = return_keyboard_events

self.LastKeyboardEvent = None

self.TextJustification = text_justification

# ------------------------- Add ONE Row to Form ------------------------- #

def AddRow(self, *args):

''' Parms are a variable number of Elements '''

NumRows = len(self.Rows) # number of existing rows is our row number

CurrentRowNumber = NumRows # this row's number

CurrentRow = [] # start with a blank row and build up

# ------------------------- Add the elements to a row ------------------------- #

for i, element in enumerate(args): # Loop through list of elements and add them to the row

element.Position = (CurrentRowNumber, i)

CurrentRow.append(element)

# ------------------------- Append the row to list of Rows ------------------------- #

self.Rows.append(CurrentRow)

# ------------------------- Add Multiple Rows to Form ------------------------- #

def AddRows(self,rows):

for row in rows:

self.AddRow(*row)

def Layout(self,rows):

self.AddRows(rows)

def LayoutAndShow(self,rows, non_blocking=False):

self.AddRows(rows)

self.Show(non_blocking=non_blocking)

return self.ReturnValues

def LayoutAndRead(self,rows, non_blocking=False):

self.AddRows(rows)

self.Show(non_blocking=non_blocking)

return self.ReturnValues

# ------------------------- ShowForm THIS IS IT! ------------------------- #

def Show(self, non_blocking=False):

self.Shown = True

# Compute num rows & num cols (it'll come in handy debugging)

self.NumRows = len(self.Rows)

self.NumCols = max(len(row) for row in self.Rows)

self.NonBlocking=non_blocking

# Search through entire form to see if any elements set the focus

# if not, then will set the focus to the first input element

found_focus = False

for row in self.Rows:

for element in row:

try:

if element.Focus:

found_focus = True

except:

pass

try:

if element.Key is not None:

self.UseDictionary = True

except:

pass

if not found_focus and self.UseDefaultFocus:

self.UseDefaultFocus = True

else:

self.UseDefaultFocus = False

# -=-=-=-=-=-=-=-=- RUN the GUI -=-=-=-=-=-=-=-=- ##