#!/usr/bin/python3

import tkinter as tk

from tkinter import filedialog

from tkinter.colorchooser import askcolor

from tkinter import ttk

import tkinter.scrolledtext as tkst

import tkinter.font

import datetime

import sys

import textwrap

import pickle

import calendar

g_time_start = 0

g_time_end = 0

g_time_delta = 0

import time

def TimerStart():

global g_time_start

g_time_start = time.time()

def TimerStop():

global g_time_delta, g_time_end

g_time_end = time.time()

g_time_delta = g_time_end - g_time_start

print(g_time_delta)

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

DEFAULT_WINDOW_ICON = 'default_icon.ico'

DEFAULT_ELEMENT_SIZE = (45,1) # In CHARACTERS

DEFAULT_BUTTON_ELEMENT_SIZE = (10,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

if sys.platform == 'darwin':

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

OFFICIAL_PYSIMPLEGUI_BUTTON_COLOR = COLOR_SYSTEM_DEFAULT # Colors should never be this long

else:

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

OFFICIAL_PYSIMPLEGUI_BUTTON_COLOR = ('white', BLUES[0]) # Colors should never be this long

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_FRAME_RELIEF = tk.GROOVE

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'

TABLE_SELECT_MODE_NONE = tk.NONE

TABLE_SELECT_MODE_BROWSE = tk.BROWSE

TABLE_SELECT_MODE_EXTENDED = tk.EXTENDED

DEFAULT_TABLE_SECECT_MODE = TABLE_SELECT_MODE_EXTENDED

TITLE_LOCATION_TOP = tk.N

TITLE_LOCATION_BOTTOM = tk.S

TITLE_LOCATION_LEFT = tk.W

TITLE_LOCATION_RIGHT = tk.E

TITLE_LOCATION_TOP_LEFT = tk.NW

TITLE_LOCATION_TOP_RIGHT = tk.NE

TITLE_LOCATION_BOTTOM_LEFT = tk.SW

TITLE_LOCATION_BOTTOM_RIGHT = tk.SE

# 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_BROWSE_FILES = 21

BUTTON_TYPE_SAVEAS_FILE = 3

BUTTON_TYPE_CLOSES_WIN = 5

BUTTON_TYPE_CLOSES_WIN_ONLY = 6

BUTTON_TYPE_READ_FORM = 7

BUTTON_TYPE_REALTIME = 9

BUTTON_TYPE_CALENDAR_CHOOSER = 30

BUTTON_TYPE_COLOR_CHOOSER = 40

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

# class ElementType(Enum):

ELEM_TYPE_TEXT = 1

ELEM_TYPE_INPUT_TEXT = 20

ELEM_TYPE_INPUT_COMBO = 21

ELEM_TYPE_INPUT_OPTION_MENU = 22

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_CANVAS = 40

ELEM_TYPE_FRAME = 41

ELEM_TYPE_GRAPH = 42

ELEM_TYPE_INPUT_SLIDER = 10

ELEM_TYPE_INPUT_LISTBOX = 11

ELEM_TYPE_OUTPUT = 300

ELEM_TYPE_COLUMN = 555

ELEM_TYPE_MENUBAR = 600

ELEM_TYPE_PROGRESS_BAR = 200

ELEM_TYPE_BLANK = 100

ELEM_TYPE_TABLE = 700

# ------------------------- Popup Buttons Types ------------------------- #

POPUP_BUTTONS_YES_NO = 1

POPUP_BUTTONS_CANCELLED = 2

POPUP_BUTTONS_ERROR = 3

POPUP_BUTTONS_OK_CANCEL = 4

POPUP_BUTTONS_OK = 0

POPUP_BUTTONS_NO_BUTTONS = 5

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

# 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 FindReturnKeyBoundButton(self, form):

for row in form.Rows:

for element in row:

if element.Type == ELEM_TYPE_BUTTON:

if element.BindReturnKey:

return element

if element.Type == ELEM_TYPE_COLUMN:

rc = self.FindReturnKeyBoundButton(element)

if rc is not None:

return rc

if element.Type == ELEM_TYPE_FRAME:

rc = self.FindReturnKeyBoundButton(element)

if rc is not None:

return rc

return None

def ReturnKeyHandler(self, event):

MyForm = self.ParentForm

button_element = self.FindReturnKeyBoundButton(MyForm)

if button_element is not None:

button_element.ButtonCallBack()

def ListboxSelectHandler(self, event):

MyForm = self.ParentForm

# first, get the results table built

# modify the Results table in the parent FlexForm object

self.ParentForm.LastButtonClicked = ''

self.ParentForm.FormRemainedOpen = True

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

def ComboboxSelectHandler(self, event):

MyForm = self.ParentForm

# first, get the results table built

# modify the Results table in the parent FlexForm object

self.ParentForm.LastButtonClicked = ''

self.ParentForm.FormRemainedOpen = True

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

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='',

justification=None, background_color=None, text_color=None, font=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

self.Justification = justification

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, font=font)

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

if disabled is True:

self.TKEntry['state'] = 'disabled'

elif disabled is False:

self.TKEntry['state'] = 'normal'

if value is not None:

try:

self.TKStringVar.set(value)

except: pass

self.DefaultText = value

def Get(self):

return self.TKStringVar.get()

def __del__(self):

super().__del__()

# ------------------------- INPUT TEXT Element lazy functions ------------------------- #

In = InputText

Input = InputText

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

# Combo #

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

class InputCombo(Element):

def __init__(self, values, default_value=None, scale=(None, None), size=(None, None), auto_size_text=None, background_color=None, text_color=None, change_submits=False, disabled=False, 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.DefaultValue = default_value

self.ChangeSubmits = change_submits

self.TKCombo = None

self.InitializeAsDisabled = disabled

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 Update(self, value=None, values=None, disabled=None):

if values is not None:

try:

self.TKCombo['values'] = values

self.TKCombo.current(0)

except: pass

self.Values = values

for index, v in enumerate(self.Values):

if v == value:

try:

self.TKCombo.current(index)

except: pass

self.DefaultValue = value

break

if disabled == True:

self.TKCombo['state'] = 'disable'

elif disabled == False:

self.TKCombo['state'] = 'enable'

def __del__(self):

try:

self.TKCombo.__del__()

except:

pass

super().__del__()

# ------------------------- INPUT COMBO Element lazy functions ------------------------- #

Combo = InputCombo

DropDown = InputCombo

Drop = InputCombo

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

# Option Menu #

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

class InputOptionMenu(Element):

def __init__(self, values, default_value=None, 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.DefaultValue = default_value

self.TKOptionMenu = 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_OPTION_MENU, scale=scale, size=size, auto_size_text=auto_size_text, background_color=bg, text_color=fg, key=key, pad=pad)

def Update(self, value=None, values=None, disabled=None):

if values is not None:

self.Values = values

if self.Values is not None:

for index, v in enumerate(self.Values):

if v == value:

try:

self.TKStringVar.set(value)

except: pass

self.DefaultValue = value

break

if disabled == True:

self.TKOptionMenu['state'] = 'disabled'

elif disabled == False:

self.TKOptionMenu['state'] = 'normal'

def __del__(self):

try:

self.TKOptionMenu.__del__()

except:

pass

super().__del__()

# ------------------------- OPTION MENU Element lazy functions ------------------------- #

OptionMenu = InputOptionMenu

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

# Listbox #

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

class Listbox(Element):

def __init__(self, values, default_values=None, select_mode=None, change_submits=False, 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.DefaultValues = default_values

self.TKListbox = None

self.ChangeSubmits = change_submits

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=None, disabled=None):

if disabled == True:

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

elif disabled == False:

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

if values is not None:

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

for item in values:

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

self.TKListbox.selection_set(0, 0)

self.Values = values

def SetValue(self, values):

for index, item in enumerate(self.Values):

try:

if item in values:

self.TKListbox.selection_set(index)

else:

self.TKListbox.selection_clear(index)

except: pass

self.DefaultValues = values

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

self.TextColor = text_color if text_color else DEFAULT_TEXT_COLOR

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

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

location = EncodeRadioRowCol(self.Position[0], self.Position[1])

if value is not None:

try:

self.TKIntVar.set(location)

except: pass

self.InitialState = value

if disabled == True:

self.TKRadio['state'] = 'disabled'

elif disabled == False:

self.TKRadio['state'] = 'normal'

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

self.TextColor = text_color if text_color else DEFAULT_TEXT_COLOR

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

def Get(self):

return self.TKIntVar.get()

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

if value is not None:

try:

self.TKIntVar.set(value)

self.InitialState = value

except: pass

if disabled == True:

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

elif disabled == False:

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

def __del__(self):

super().__del__()

# ------------------------- CHECKBOX Element lazy functions ------------------------- #

CB = Checkbox

CBox = Checkbox

Check = Checkbox

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

# Spin #

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

class Spin(Element):

# Values = None

# TKSpinBox = None

def __init__(self, values, initial_value=None, change_submits=False, 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.ChangeSubmits = change_submits

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 Update(self, value=None, values=None, disabled=None):

if values != None:

old_value = self.TKStringVar.get()

self.Values = values

self.TKSpinBox.configure(values=values)

self.TKStringVar.set(old_value)

if value is not None:

try:

self.TKStringVar.set(value)

except: pass

self.DefaultValue = value

if disabled == True:

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

elif disabled == False:

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

def SpinChangedHandler(self, event):

# first, get the results table built

# modify the Results table in the parent FlexForm object

self.ParentForm.LastButtonClicked = ''

self.ParentForm.FormRemainedOpen = True

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

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, value=None, disabled=None):

if value is not None:

try:

self.TKText.delete('1.0', tk.END)

self.TKText.insert(1.0, value)

except: pass

self.DefaultText = value

if disabled == True:

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

elif disabled == False:

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

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, key=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, key=key)

return

def Update(self, value = None, background_color=None, text_color=None, font=None):

if value is not None:

self.DisplayText=value

stringvar = self.TKStringVar

stringvar.set(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)

if font is not None:

self.TKText.configure(font=font)

def __del__(self):

super().__del__()

# ------------------------- Text Element lazy functions ------------------------- #

Txt = Text

T = Text

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

# 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)

if BarColor != COLOR_SYSTEM_DEFAULT:

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

else:

s.configure(str(length)+str(width)+"my.Horizontal.TProgressbar", 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)

if BarColor != COLOR_SYSTEM_DEFAULT:

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

else:

s.configure(str(length)+str(width)+"my.Vertical.TProgressbar", 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=None, max=None):

if max is not None:

self.Max = max

try:

self.TKProgressBarForReal.config(maximum=max)

except:

return False

if count is not None and count > self.Max: return False

if count is not None:

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, font=None, pad=None):

frame = tk.Frame(parent)

tk.Frame.__init__(self, frame)

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

if background_color and background_color != COLOR_SYSTEM_DEFAULT:

self.output.configure(background=background_color)

frame.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", expand=True)

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

frame.pack(side="left", padx=pad[0], pady=pad[1], expand=True, fill='y')

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, font=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, font=font)

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", "*.*"),), initial_folder=None, 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, default_value = None, font=None, bind_return_key=False, focus=False, pad=None, key=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

self.TKCal = None

self.DefaultValue = None

self.InitialFolder = initial_folder

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

return

# Realtime button release callback

def ButtonReleaseCallBack(self, parm):

r, c = self.Position

self.LastButtonClickedWasRealtime = False

self.ParentForm.LastButtonClicked = None

# Realtime button callback

def ButtonPressCallBack(self, parm):

r, c = self.Position

self.ParentForm.LastButtonClickedWasRealtime = True

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

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

target_element = None

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 == (None, None):

strvar = self.TKStringVar

else:

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

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

if self.BType == BUTTON_TYPE_BROWSE_FOLDER:

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

if folder_name != '':

try:

strvar.set(folder_name)

self.TKStringVar.set(folder_name)

except: pass

elif self.BType == BUTTON_TYPE_BROWSE_FILE:

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

if file_name != '':

strvar.set(file_name)

self.TKStringVar.set(file_name)

elif self.BType == BUTTON_TYPE_COLOR_CHOOSER:

color = tk.colorchooser.askcolor() # show the 'get file' dialog box

color = color[1] # save only the #RRGGBB portion

strvar.set(color)

self.TKStringVar.set(color)

elif self.BType == BUTTON_TYPE_BROWSE_FILES:

file_name = tk.filedialog.askopenfilenames(filetypes=filetypes, initialdir=self.InitialFolder)

if file_name != '':

file_name = ';'.join(file_name)

strvar.set(file_name)

self.TKStringVar.set(file_name)

elif self.BType == BUTTON_TYPE_SAVEAS_FILE:

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

if file_name != '':

strvar.set(file_name)

self.TKStringVar.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

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

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: