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(int(g_time_delta*1000))

"""

Welcome to the "core" PySimpleGUI code....

It's a mess.... really... it's a mess internally... it's the external-facing interfaces that

are not a mess. The Elements and the methods for them are well-designed.

PEP8 - this code is far far from PEP8 compliant.

It was written PRIOR to learning that PEP8 existed.

The variable and function naming in particular are not compliant. There is

liberal use of CamelVariableAndFunctionNames. If you've got a serious enough problem with this

that you'll pass on this package, then that's your right and I invite you to do so. However, if

perhaps you're a practical thinker where it's the results that matter, then you'll have no

trouble with this code base. There is consisency however.

I truly hope you get a lot of enjoyment out of using PySimpleGUI. It came from good intentions.

"""

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

DEFAULT_TOOLTIP_OFFSET = (20,-20)

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

THEME_DEFAULT = 'default'

THEME_WINNATIVE = 'winnative'

THEME_CLAM = 'clam'

THEME_ALT = 'alt'

THEME_CLASSIC = 'classic'

THEME_VISTA = 'vista'

THEME_XPNATIVE = 'xpnative'

# DEFAULT_METER_ORIENTATION = 'Vertical'

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

ThisRow = 555666777 # magic number

# DEFAULT_WINDOW_ICON = ''

MESSAGE_BOX_LINE_WIDTH = 60

# "Special" Key Values.. reserved

# Key representing a Read timeout

TIMEOUT_KEY = '__TIMEOUT__'

# Key indicating should not create any return values for element

WRITE_ONLY_KEY = '__WRITE ONLY__'

MENU_DISABLED_CHARACTER = '!'

MENU_KEY_SEPARATOR = '::'

# 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

self.hidden_master_root = 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 = 'text'

ELEM_TYPE_INPUT_TEXT = 'input'

ELEM_TYPE_INPUT_COMBO = 'combo'

ELEM_TYPE_INPUT_OPTION_MENU = 'option menu'

ELEM_TYPE_INPUT_RADIO = 'radio'

ELEM_TYPE_INPUT_MULTILINE = 'multiline'

ELEM_TYPE_INPUT_CHECKBOX = 'checkbox'

ELEM_TYPE_INPUT_SPIN = 'spind'

ELEM_TYPE_BUTTON = 'button'

ELEM_TYPE_IMAGE = 'image'

ELEM_TYPE_CANVAS = 'canvas'

ELEM_TYPE_FRAME = 'frame'

ELEM_TYPE_GRAPH = 'graph'

ELEM_TYPE_TAB = 'tab'

ELEM_TYPE_TAB_GROUP = 'tabgroup'

ELEM_TYPE_INPUT_SLIDER = 'slider'

ELEM_TYPE_INPUT_LISTBOX = 'listbox'

ELEM_TYPE_OUTPUT = 'output'

ELEM_TYPE_COLUMN = 'column'

ELEM_TYPE_MENUBAR = 'menubar'

ELEM_TYPE_PROGRESS_BAR = 'progressbar'

ELEM_TYPE_BLANK = 'blank'

ELEM_TYPE_TABLE = 'table'

ELEM_TYPE_TREE = 'tree'

ELEM_TYPE_ERROR = 'error'

ELEM_TYPE_SEPARATOR = 'separator'

ELEM_TYPE_STATUSBAR = 'statusbar'

# ------------------------- 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() + DEFAULT_TOOLTIP_OFFSET[0]

y = self.widget.winfo_rooty() + self.widget.winfo_height() + DEFAULT_TOOLTIP_OFFSET[1]

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

self.tipwindow.wm_overrideredirect(True)

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

self.tipwindow.wm_attributes("-topmost", 1)

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

if self.ParentForm.CurrentlyRunningMainloop:

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

# 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

if self.ParentForm.CurrentlyRunningMainloop:

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

def ComboboxSelectHandler(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

if self.ParentForm.CurrentlyRunningMainloop:

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

def RadioHandler(self):

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

self.ParentForm.LastButtonClicked = ''

self.ParentForm.FormRemainedOpen = True

if self.ParentForm.CurrentlyRunningMainloop:

self.ParentForm.TKroot.quit()

def CheckboxHandler(self):

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

self.ParentForm.LastButtonClicked = ''

self.ParentForm.FormRemainedOpen = True

if self.ParentForm.CurrentlyRunningMainloop:

self.ParentForm.TKroot.quit()

def TabGroupSelectHandler(self, event):

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

self.ParentForm.LastButtonClicked = ''

self.ParentForm.FormRemainedOpen = True

if self.ParentForm.CurrentlyRunningMainloop:

self.ParentForm.TKroot.quit()

def KeyboardHandler(self, event):

if self.Key is not None:

self.ParentForm.LastButtonClicked = self.Key

else:

self.ParentForm.LastButtonClicked = ''

self.ParentForm.FormRemainedOpen = True

if self.ParentForm.CurrentlyRunningMainloop:

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), disabled=False, password_char='',

justification=None, background_color=None, text_color=None, font=None, tooltip=None,

change_submits=False, enable_events=False,

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

self.Disabled = disabled

self.ChangeSubmits = change_submits or enable_events

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

font=font, tooltip=tooltip)

def Update(self, value=None, disabled=None, select=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

if select:

self.TKEntry.select_range(0, 'end')

def Get(self):

try:

text = self.TKStringVar.get()

except:

text = ''

return text

def SetFocus(self):

try:

self.TKEntry.focus_set()

except:

pass

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, enable_events=False, disabled=False, key=None, pad=None, tooltip=None,

readonly=False, font=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 or enable_events

self.TKCombo = None

# self.InitializeAsDisabled = disabled

self.Disabled = disabled

self.Readonly = readonly

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

def Update(self, value=None, values=None, set_to_index=None, disabled=None, readonly=None, font=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'

if readonly is not None:

self.Readonly = readonly

if self.Readonly:

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

if font is not None:

self.TKText.configure(font=font)

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 OptionMenu(Element):

def __init__(self, values, default_value=None, size=(None, None), disabled=False, auto_size_text=None,

background_color=None, text_color=None, key=None, pad=None, tooltip=None):

'''

InputOptionMenu

:param values:

:param default_value:

:param size:

:param disabled:

:param auto_size_text:

:param background_color:

:param text_color:

:param key:

:param pad:

:param tooltip:

'''

self.Values = values

self.DefaultValue = default_value

self.TKOptionMenu = None

self.Disabled = 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_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 ------------------------- #

InputOptionMenu = OptionMenu

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

# Listbox #

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

class Listbox(Element):

def __init__(self, values, default_values=None, select_mode=None, change_submits=False,enable_events=False, bind_return_key=False, size=(None, None), disabled=False, auto_size_text=None, font=None, background_color=None, text_color=None, key=None, pad=None, tooltip=None):

'''

Listbox Element

:param values:

:param default_values:

:param select_mode:

:param change_submits:

:param bind_return_key:

:param size:

:param disabled:

:param auto_size_text:

:param font:

:param background_color:

:param text_color:

:param key:

:param pad:

:param tooltip:

'''

self.Values = values

self.DefaultValues = default_values

self.TKListbox = None

self.ChangeSubmits = change_submits or enable_events

self.BindReturnKey = bind_return_key

self.Disabled = disabled

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

if set_to_index is not None:

self.TKListbox.selection_clear(0)

try:

self.TKListbox.selection_set(set_to_index, set_to_index)

except:

pass

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 GetListValues(self):

return self.Values

def __del__(self):

try:

self.TKListBox.__del__()

except:

pass

super().__del__()

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

# Radio #

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

class Radio(Element):

def __init__(self, text, group_id, default=False, disabled=False, size=(None, None), auto_size_text=None,

background_color=None, text_color=None, font=None, key=None, pad=None, tooltip=None, change_submits=False, enable_events=False):

'''

Radio Button Element

:param text:

:param group_id:

:param default:

:param disabled:

:param size:

:param auto_size_text:

:param background_color:

:param text_color:

:param font:

:param key:

:param pad:

:param tooltip:

:param change_submits:

'''

self.InitialState = default

self.Text = text

self.TKRadio = None

self.GroupID = group_id

self.Value = None

self.Disabled = disabled

self.TextColor = text_color or DEFAULT_TEXT_COLOR

self.ChangeSubmits = change_submits or enable_events

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,enable_events=False, disabled=False, key=None, pad=None, tooltip=None):

'''

Checkbox Element

:param text:

:param default:

:param size:

:param auto_size_text:

:param font:

:param background_color:

:param text_color:

:param change_submits:

:param disabled:

:param key:

:param pad:

:param tooltip:

'''

self.Text = text

self.InitialState = default

self.Value = None

self.TKCheckbutton = None

self.Disabled = disabled

self.TextColor = text_color if text_color else DEFAULT_TEXT_COLOR

self.ChangeSubmits = change_submits or enable_events

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, disabled=False, change_submits=False,enable_events=False , size=(None, None),

auto_size_text=None, font=None, background_color=None, text_color=None, key=None, pad=None,

tooltip=None):

'''

Spinner Element

:param values:

:param initial_value:

:param disabled:

:param change_submits:

:param size:

:param auto_size_text:

:param font:

:param background_color:

:param text_color:

:param key:

:param pad:

:param tooltip:

'''

self.Values = values

self.DefaultValue = initial_value

self.ChangeSubmits = change_submits or enable_events

self.TKSpinBox = None

self.Disabled = 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_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

if self.ParentForm.CurrentlyRunningMainloop:

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, disabled=False, autoscroll=False, size=(None, None),

auto_size_text=None, background_color=None, text_color=None, change_submits=False, enable_events=False,do_not_clear=False, key=None, focus=False, font=None, pad=None, tooltip=None):

'''

Multiline Element

:param default_text:

:param enter_submits:

:param disabled:

:param autoscroll:

:param size:

:param auto_size_text:

:param background_color:

:param text_color:

:param change_submits:

:param enable_events:

:param do_not_clear:

:param key:

:param focus:

:param font:

:param pad:

:param tooltip:

'''

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

self.Disabled = disabled

self.ChangeSubmits = change_submits or enable_events