#!/usr/bin/python3

from __future__ import print_function

from __future__ import division

from __future__ import unicode_literals

from __future__ import absolute_import

from builtins import super

from builtins import open

from builtins import range

from builtins import int

from builtins import str

from builtins import object

from future import standard_library

standard_library.install_aliases()

import sys

if sys.version_info[0] >= 3:

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

else:

import tkinter as tk

import tkinter.filedialog

import tkinter.ttk

import tkinter.colorchooser

import tkinter.font

import tkinter.scrolledtext

import types

import datetime

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

DEFAULT_TOOLTIP_TIME = 400

#################### 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(object):

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_TAB = 50

ELEM_TYPE_TAB_GROUP = 51

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

ELEM_TYPE_ERROR = 666

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

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

# ToolTip used by the Elements #

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

class ToolTip(object):

""" Create a tooltip for a given widget

(inspired by https://stackoverflow.com/a/36221216)

"""

def __init__(self, widget, text, timeout=DEFAULT_TOOLTIP_TIME):

self.widget = widget

self.text = text

self.timeout = timeout

#self.wraplength = wraplength if wraplength else widget.winfo_screenwidth() // 2

self.tipwindow = None

self.id = None

self.x = self.y = 0

self.widget.bind("<Enter>", self.enter)

self.widget.bind("<Leave>", self.leave)

self.widget.bind("<ButtonPress>", self.leave)

def enter(self, event=None):

self.schedule()

def leave(self, event=None):

self.unschedule()

self.hidetip()

def schedule(self):

self.unschedule()

self.id = self.widget.after(self.timeout, self.showtip)

def unschedule(self):

if self.id:

self.widget.after_cancel(self.id)

self.id = None

def showtip(self):

if self.tipwindow:

return

x = self.widget.winfo_rootx() + 20

y = self.widget.winfo_rooty() + self.widget.winfo_height() - 20

self.tipwindow = tk.Toplevel(self.widget)

self.tipwindow.wm_overrideredirect(True)

self.tipwindow.wm_geometry("+%d+%d" % (x, y))

label = tkinter.ttk.Label(self.tipwindow, text=self.text, justify=tk.LEFT,

background="#ffffe0", relief=tk.SOLID, borderwidth=1)

label.pack()

def hidetip(self):

if self.tipwindow:

self.tipwindow.destroy()

self.tipwindow = None

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

# Cascading structure.... Objects get larger #

# Button #

# Element #

# Row #

# Form #

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

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

# Element CLASS #

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

class Element(object):

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

self.Size = size

self.Type = type

self.AutoSizeText = auto_size_text

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.ParentContainer=None # will be a Form, Column, or Frame element

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

self.Tooltip = tooltip

self.TooltipObject = None

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

if element.Type == ELEM_TYPE_TAB_GROUP:

rc = self.FindReturnKeyBoundButton(element)

if rc is not None:

return rc

if element.Type == ELEM_TYPE_TAB:

rc = self.FindReturnKeyBoundButton(element)

if rc is not None:

return rc

return None

def TextClickedHandler(self, event):

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

self.ParentForm.LastButtonClicked = self.DisplayText

self.ParentForm.FormRemainedOpen = True

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

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

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

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

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

self.ParentForm.LastButtonClicked = ''

self.ParentForm.FormRemainedOpen = True

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

def CheckboxHandler(self):

MyForm = self.ParentForm

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

self.ParentForm.LastButtonClicked = ''

self.ParentForm.FormRemainedOpen = True

self.ParentForm.TKroot.quit()

def TabGroupSelectHandler(self, event):

MyForm = self.ParentForm

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

self.ParentForm.LastButtonClicked = ''

self.ParentForm.FormRemainedOpen = True

self.ParentForm.TKroot.quit()

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 ='', size=(None, None), auto_size_text=None, password_char='',

justification=None, background_color=None, text_color=None, font=None, tooltip=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 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, size=size, auto_size_text=auto_size_text, background_color=bg, text_color=fg, key=key, pad=pad, font=font, tooltip=tooltip)

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, size=(None, None), auto_size_text=None, background_color=None, text_color=None, change_submits=False, disabled=False, key=None, pad=None, tooltip=None):

'''

Input Combo Box Element (also called Dropdown box)

:param values:

: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, size=size, auto_size_text=auto_size_text, background_color=bg, text_color=fg, key=key, pad=pad, tooltip=tooltip)

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

if values is not None:

try:

self.TKCombo['values'] = values

self.TKCombo.current(0)

except: pass

self.Values = values

if value is not None:

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

if v == value:

try:

self.TKCombo.current(index)

except: pass

self.DefaultValue = value

break

if set_to_index is not None:

try:

self.TKCombo.current(set_to_index)

self.DefaultValue = self.Values[set_to_index]

except:

pass

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, size=(None, None), auto_size_text=None, background_color=None, text_color=None, key=None, pad=None, tooltip=None):

'''

Input Combo Box Element (also called Dropdown box)

:param values:

: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, size=size, auto_size_text=auto_size_text, background_color=bg, text_color=fg, key=key, pad=pad, tooltip=tooltip)

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, bind_return_key=False, size=(None, None), auto_size_text=None, font=None, background_color=None, text_color=None, key=None, pad=None, tooltip=None):

'''

Listbox Element

:param values:

:param select_mode: SELECT_MODE_BROWSE, SELECT_MODE_EXTENDED, SELECT_MODE_MULTIPLE, SELECT_MODE_SINGLE

:param font:

: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

self.BindReturnKey = bind_return_key

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, size=size, auto_size_text=auto_size_text, font=font, background_color=bg, text_color=fg, key=key, pad=pad, tooltip=tooltip)

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, size=(None, None), auto_size_text=None, background_color=None, text_color=None, font=None, key=None, pad=None, tooltip=None):

'''

Radio Button Element

:param text:

:param group_id:

:param default:

: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, size=size, auto_size_text=auto_size_text, font=font, background_color=background_color, text_color=self.TextColor, key=key, pad=pad, tooltip=tooltip)

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, size=(None, None), auto_size_text=None, font=None, background_color=None, text_color=None, change_submits=False, key=None, pad=None, tooltip=None):

'''

Check Box Element

:param text:

:param default:

: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

self.ChangeSubmits = change_submits

super().__init__(ELEM_TYPE_INPUT_CHECKBOX, size=size, auto_size_text=auto_size_text, font=font,

background_color=background_color, text_color=self.TextColor, key=key, pad=pad, tooltip=tooltip)

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, size=(None, None), auto_size_text=None, font=None, background_color=None, text_color=None, key=None, pad=None, tooltip=None):

'''

Spin Box Element

:param values:

:param initial_value:

: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, size, auto_size_text, font=font,background_color=bg, text_color=fg, key=key, pad=pad, tooltip=tooltip)

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

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

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, autoscroll=False, size=(None, None), auto_size_text=None, background_color=None, text_color=None, do_not_clear=False, key=None, focus=False, pad=None, tooltip=None):

'''

Input Multi-line Element

:param default_text:

:param enter_submits:

: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

self.Autoscroll = autoscroll

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

return

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

if value is not None:

try:

if not append:

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

self.TKText.insert(tk.END, value)

except: pass

self.DefaultText = value

if self.Autoscroll:

self.TKText.see(tk.END)

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, size=(None, None), auto_size_text=None, click_submits=None, relief=None, font=None, text_color=None, background_color=None,justification=None, pad=None, key=None, tooltip=None):

'''

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

:param text: The text to display

: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

self.Relief = relief

self.ClickSubmits = click_submits

if background_color is None:

bg = DEFAULT_TEXT_ELEMENT_BACKGROUND_COLOR

else:

bg = background_color

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

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(object):

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 = tkinter.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 = tkinter.ttk.Progressbar(root, maximum=self.Max, style=str(length)+str(width)+'my.Horizontal.TProgressbar', length=length, orient=tk.HORIZONTAL, mode='determinate')

else:

s = tkinter.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 = tkinter.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, size=(None, None), background_color=None, text_color=None, pad=None, font=None, tooltip=None, key=None):

'''

Output Element - reroutes stdout, stderr to this window