def __init__(self, master, temp, MW, Kow, density, sfont):
"""Constructor method."""
self.version = 'CapSim 3.3' #system.version
self.fonttype = 'Arial 10' #system.fonttype
self.master = master
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.sfont = sfont
self.temp = temp
self.MW = MW
self.Kow = Kow
self.density = density
self.Dw = DoubleVar()
self.Dwoptions = ['Hayduk and Laudie', 'None']
self.Dwoption = StringVar(value=self.Dwoptions[0])
self.Koc = DoubleVar()
self.Kocoptions = ['Baker', 'PAH', 'PCB', 'None']
self.Kocoption = StringVar(value=self.Kocoptions[0])
self.Kdoc = DoubleVar()
self.Kdocoptions = ['Burkhard', 'PAH', 'PCB', 'None']
self.Kdocoption = StringVar(value=self.Kdocoptions[0])
self.top = None
def __init__(self, master, version, fonttype, timeunit, lengthunit,
chemicals, taucoefs, BCs):
"""Constructor method."""
self.master = master
self.version = version
self.fonttype = fonttype
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.superfont = get_superfont(self.fonttype)
self.Decays = ['None', 'First order']
self.Evaps = ['None', 'First order']
self.top = None
self.cancelflag = 0
self.timeunit = timeunit
self.lengthunit = lengthunit
self.Q = DoubleVar(value=taucoefs['Q'])
self.V = DoubleVar(value=taucoefs['V'])
self.h = DoubleVar(value=taucoefs['h'])
self.Qevap = DoubleVar(value=taucoefs['Qevap'])
self.doc = DoubleVar(value=taucoefs['DOC'])
self.Decay = StringVar(value=taucoefs['Decay'])
self.Evap = StringVar(value=taucoefs['Evap'])
self.chemicals = chemicals
self.kdecays = []
self.kevaps = []
for chemical in self.chemicals:
self.kdecays.append(BCs[chemical.name].kdecay)
self.kevaps.append(BCs[chemical.name].kevap)
def __init__(self, master, version, fonttype, bltype, blcoefs):
"""Constructor method."""
self.version = version
self.fonttype = fonttype
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.superfont = get_superfont(self.fonttype)
self.bltypes = ['River', 'Lake']
self.bltype = StringVar(value=bltype)
self.top = None
self.cancelflag = 0
#Parameters for Mass transfer coefficient in river
self.vx = DoubleVar(value=blcoefs['vx'])
self.n = DoubleVar(value=blcoefs['n'])
self.hriver = DoubleVar(value=blcoefs['hriver'])
self.rh = DoubleVar(value=blcoefs['rh'])
self.nu = DoubleVar(value=blcoefs['nu'])
#Parameters for Mass transfer coefficient in lake
self.rhoair = DoubleVar(value=blcoefs['rhoair'])
self.rhowater = DoubleVar(value=blcoefs['rhowater'])
self.vwind = DoubleVar(value=blcoefs['vwind'])
self.hlake = DoubleVar(value=blcoefs['hlake'])
self.llake = DoubleVar(value=blcoefs['llake'])
def __init__(self, master, system, solid):
"""Constructor method. Defines the parameters to be obtained in this
window."""
self.master = master
self.fonttype = system.fonttype
self.version = system.version
self.superfont = get_superfont(self.fonttype) #superscript font
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.top = None #flag for existence of toplevel#
self.name = StringVar(value=solid.name) #stores the chemical name
self.e = DoubleVar(value=solid.e) #stores the porosity
self.rho = DoubleVar(value=solid.rho) #stores the bulk density
self.foc = DoubleVar(
value=solid.foc) #stores the organic carbon fraction
self.tort = StringVar(
value=solid.tort) #stores the default tortuosity correction
self.sorp = StringVar(
value=solid.sorp) #stores the default sorption correction
self.Ref = StringVar(
value=solid.Ref) #stores the default sorption correction
self.cancelflag = 0
def __init__(self, master, system, reaction, editflag):
"""Constructor method. Makes the GUI using the list of "Layer" objects
"layers." """
# Read the Tkinter information
self.master = master
self.fonttype = system.fonttype
self.formulatype = system.formulatype
self.version = system.version
self.superfont = get_superfont(self.fonttype)
self.subfont = get_superfont(self.formulatype)
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.bgcolor = self.frame.cget('bg')
self.top = None
self.system = system
# Read the system information
self.chemicals = system.chemicals
self.reaction = reaction
self.editflag = editflag
# Define the reaction chemical information
self.chemical_list = [chemical.name for chemical in self.chemicals]
self.formula_list = [chemical.formula for chemical in self.chemicals]
self.MW_list = [chemical.MW for chemical in self.chemicals]
self.models = ['Fundamental', 'User-defined']
self.name = StringVar(value='Reaction ' + str(reaction.number))
self.model = StringVar(value=self.models[0])
self.reactants = []
self.products = []
#self.stoichcoef = reaction.stoichcoef
if editflag == 1:
self.name = StringVar(value=reaction.name)
self.model = StringVar(value=reaction.model)
self.reactants = [
reactant.copy() for reactant in reaction.reactants
]
self.products = [product.copy() for product in reaction.products]
for reactant in self.reactants:
reactant.coef = DoubleVar(value=reactant.coef)
reactant.index = DoubleVar(value=reactant.index)
reactant.name = StringVar(value=reactant.name)
reactant.formula = StringVar(value=reactant.formula)
reactant.MW = DoubleVar(value=reactant.MW)
for product in self.products:
product.coef = DoubleVar(value=product.coef)
product.name = StringVar(value=product.name)
product.formula = StringVar(value=product.formula)
product.MW = DoubleVar(value=product.MW)
self.cancelflag = 0
def __init__(self, master, system, layer, layers, editflag):
"""Constructor method. Defines the parameters to be obtained in this
window."""
self.master = master
self.fonttype = system.fonttype
self.version = system.version
self.superfont = get_superfont(self.fonttype) #superscript font
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.top = None #flag for existence of toplevel#
self.system = system
self.lengthunit = system.lengthunit
self.layer = layer
self.layers = layers
self.types = []
self.tort_types = []
self.torts = layer.torts
self.h = DoubleVar(value=10.0)
self.alpha = DoubleVar(value=1.0)
self.doc = DoubleVar(value=0.0)
for matrix in system.matrices:
self.types.append(matrix.name)
self.tort_types.append(matrix.components[0].tort)
self.type = StringVar(value=self.types[0])
self.tort = StringVar(value=self.tort_types[0])
self.editflag = editflag
self.cancelflag = 0
if self.editflag == 1:
self.type.set(layer.type)
self.tort.set(layer.tort)
self.h.set(layer.h)
self.alpha.set(layer.alpha)
self.doc.set(layer.doc)
self.names = []
if len(layers) == 0:
self.names.append('Deposition')
self.names.append('Layer 1')
else:
for layer in self.layers:
self.names.append(layer.name)
self.names.append('Layer ' + str(layers[-1].number + 1))
if self.names[0] == 'Deposition': self.names.remove(self.names[0])
else: self.names.insert(0, 'Deposition')
if self.editflag == 0: self.name = StringVar(value=self.names[-1])
else: self.name = StringVar(value=self.layer.name)
def addreactant(self):
self.reactants.append(Reactant(len(self.reactants) + 1))
self.reactants[-1].coef = DoubleVar(value=1)
self.reactants[-1].name = StringVar(value=self.chemical_list[0])
self.reactants[-1].formula = StringVar(value=self.formula_list[0])
self.reactants[-1].index = DoubleVar(value=1)
self.reactants[-1].MW = DoubleVar(value=self.MW_list[0])
self.updatereaction()
def __init__(self, master, system):
"""Constructor method. Defines the parameters to be obtained in this
window."""
self.master = master
self.system = system
self.fonttype = system.fonttype
self.version = system.version
self.superfont = get_superfont(self.fonttype) #superscript font
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.advs = ['None', 'Steady flow', 'Period oscillation']
self.bios = ['None', 'Uniform', 'Depth-dependent']
self.cons = ['None', 'Consolidation']
self.adv = StringVar(value=self.advs[0]) #tidal flag
self.bio = StringVar(value=self.bios[0]) #bioturbation flag
self.con = StringVar(value=self.cons[0]) #consolidation flag
self.hbio = DoubleVar(value=10.) #bioturbation depth
self.sigma = DoubleVar(value=10.) #bioturbation depth
self.Dbiop = DoubleVar(value=1.) #particle bioturbation coeff
self.Dbiopw = DoubleVar(value=100.) #pore water bioturbation coeff
self.Vdar = DoubleVar(value=0.) #Darcy velocity
self.Vtidal = DoubleVar(value=0.) #Tidal velocity
self.ptidal = DoubleVar(value=0.0014) #Tidal frequency
self.hcon = DoubleVar(value=0) #total consolidation
self.t90 = DoubleVar(value=1.) #time to 90% consolidation
self.top = None #flag for existence of toplevel
if system.layers[0].number == 0: self.toplayer_h = system.layers[1].h
else: self.toplayer_h = system.layers[0].h
self.lengthunit = system.lengthunit
self.timeunit = system.timeunit
self.diffunit = system.diffunit
self.diffunits = system.diffunits
try:
self.adv.set(system.adv)
self.bio.set(system.bio)
self.con.set(system.con)
self.Vdar.set(system.Vdar)
self.hbio.set(system.hbio)
self.sigma.set(system.sigma)
self.Dbiop.set(system.Dbiop)
self.Dbiopw.set(system.Dbiopw)
self.Vtidal.set(system.Vtidal)
self.ptidal.set(system.ptidal)
self.hcon.set(system.hcon)
self.t90.set(system.t90)
except:
pass
def __init__(self, parent):
CtxSubPanel.__init__(self, parent)
self.my_changes = 0
self.var_width_number = DoubleVar(self.mw.root)
self.var_height_number = DoubleVar(self.mw.root)
var_width_unit = StringVar(self.mw.root)
var_height_unit = StringVar(self.mw.root)
unit = config.preferences.default_unit
self.var_width = LengthVar(10, unit, self.var_width_number,
var_width_unit)
self.var_height = LengthVar(10, unit, self.var_height_number,
var_height_unit)
jump = config.preferences.default_unit_jump
self.var_width.set(0)
self.var_height.set(0)
label = TLabel(self.panel, image='size_h')
label.pack(side=LEFT)
self.entry_width = TSpinbox(self.panel,
var=0,
vartype=1,
textvariable=self.var_width_number,
min=0,
max=50000,
step=jump,
width=6,
command=self.applyResize)
tooltips.AddDescription(self.entry_width, _("Width of selection"))
self.entry_width.pack(side=LEFT, padx=5)
label = TLabel(self.panel, image='size_v')
label.pack(side=LEFT)
self.entry_height = TSpinbox(self.panel,
var=0,
vartype=1,
textvariable=self.var_height_number,
min=0,
max=50000,
step=jump,
width=6,
command=self.applyResize)
tooltips.AddDescription(self.entry_height, _("Height of selection"))
self.entry_height.pack(side=LEFT, padx=5)
self.ReSubscribe()
config.preferences.Subscribe(CHANGED, self.update_pref)
def __init__(self, master, system, matrix, matrices, materials, editflag,
newflag):
"""Constructor method. Defines the parameters to be obtained in this
window."""
self.master = master
self.fonttype = system.fonttype
self.version = system.version
self.superfont = get_superfont(self.fonttype) #superscript font
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.top = None #flag for existence of toplevel#
self.matrix = matrix
self.matrices = matrices
self.materials = materials
self.matrices_list = self.materials.keys()
self.matrices_list.sort()
for matrix in (self.matrices):
if matrix.number <> self.matrix.number and len(
matrix.components) == 1 and self.matrices_list.count(
matrix.name) > 0:
self.matrices_list.remove(matrix.name)
self.model = StringVar(
value='Linear') #Define the imaginary model for the components
self.name = StringVar(value=self.matrices_list[0]) #matrix name
self.e = DoubleVar(value=0.5) #stores the porosity
self.rho = DoubleVar(value=1.0) #stores the bulk density
self.foc = DoubleVar(value=0.01) #stores the organic carbon fraction
self.editflag = editflag
self.newflag = newflag
self.cancelflag = 0
if editflag == 0:
self.components = [MatrixComponent(1)] #Define components
if editflag == 1: #Detemine whether the chemical is added or edited
self.components = self.matrix.components
self.name.set(self.matrix.name)
self.model.set(self.matrix.model)
self.e.set(self.matrix.e)
self.rho.set(self.matrix.rho)
self.foc.set(self.matrix.foc)
def test_get_from_int(self):
v = DoubleVar(self.root, 1.23, "name")
self.assertAlmostEqual(1.23, v.get())
self.root.globalsetvar("name", "3.45")
self.assertAlmostEqual(3.45, v.get())
self.root.globalsetvar("name", "456")
self.assertAlmostEqual(456, v.get())
def __init__(self, parent):
self.my_changes = 0
CtxSubPanel.__init__(self, parent)
self.var_jump_number = DoubleVar(self.mw.root)
unit = config.preferences.default_unit
var_jump_unit = StringVar(self.mw.root)
self.var_jump = LengthVar(10, unit, self.var_jump_number,
var_jump_unit)
label = TLabel(self.panel, text=_("Jump:"))
label.pack(side=LEFT, padx=2)
self.entry_jump = TSpinbox(self.panel,
var=0,
vartype=1,
textvariable=self.var_jump_number,
min=0,
max=1000,
step=.1,
width=6,
command=self.applyJump)
self.entry_jump.pack(side=LEFT, padx=2)
config.preferences.Subscribe(CHANGED, self.update)
self.var_jump.set(config.preferences.handle_jump)
self.update(0, 0)
def test_get_from_int(self):
v = DoubleVar(self.root, 1.23, 'name')
self.assertAlmostEqual(1.23, v.get())
self.root.globalsetvar('name', '3.45')
self.assertAlmostEqual(3.45, v.get())
self.root.globalsetvar('name', '456')
self.assertAlmostEqual(456, v.get())
def __init__(self, master, system, solid, solid_database, editflag):
"""Constructor method. Defines the parameters to be obtained in this
window."""
self.master = master
self.fonttype = system.fonttype
self.version = system.version
self.superfont = get_superfont(self.fonttype) #superscript font
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.top = None #flag for existence of toplevel#
self.solid = solid
self.solid_database = solid_database
self.torts = ['Millington & Quirk', 'Boudreau', 'None']
self.sorps = [
'Linear--Kd specified', 'Linear--Kocfoc', 'Freundlich', 'Langmuir'
]
self.name = StringVar(
value='Solid ' +
str(solid_database[-1].number)) #stores the chemical name
self.e = DoubleVar(value=0.5) #stores the porosity
self.rho = DoubleVar(value=1.0) #stores the bulk density
self.foc = DoubleVar(value=0.01) #stores the organic carbon fraction
self.tort = StringVar(
value=self.torts[0]) #stores the default tortuosity correction
self.sorp = StringVar(
value=self.sorps[0]) #stores the default sorption correction
self.Ref = StringVar(value='') #stores the density
self.editflag = editflag
self.cancelflag = 0
if editflag == 1: #Detemine whether the chemical is added or edited
self.name.set(solid.name)
self.e.set(solid.e)
self.rho.set(solid.rho)
self.foc.set(solid.foc)
self.tort.set(solid.tort)
self.sorp.set(solid.sorp)
self.Ref.set(solid.Ref)
def __init__(self, master, system, chemical):
"""Constructor method. Defines the parameters to be obtained in this window."""
self.master = master
self.fonttype = system.fonttype
self.version = system.version
self.superfont = get_superfont(self.fonttype) #superscript font
self.frame = Frame(master.frame)
self.tframe = Frame(master.tframe)
self.bframe = Frame(master.bframe)
self.top = None #flag for existence of toplevel#
self.soluableflag = chemical.soluable
self.name = StringVar(value=chemical.name)
self.MW = DoubleVar(value=chemical.MW)
self.formula = StringVar(value=chemical.formula)
self.temp = DoubleVar(value=chemical.temp)
self.Dw = DoubleVar(value=chemical.Dw)
self.Koc = DoubleVar(value=chemical.Koc)
self.Kdoc = DoubleVar(value=chemical.Kdoc)
self.Ref = StringVar(value=chemical.Ref)
self.Kf = DoubleVar(value=chemical.Kf)
self.N = DoubleVar(value=chemical.N)
self.chemical = chemical
self.cancelflag = 0
def __init__(self, master, system, matrix, matrices, materials, editflag):
"""Constructor method. Defines the parameters to be obtained in this
window."""
self.master = master
self.fonttype = system.fonttype
self.version = system.version
self.superfont = get_superfont(self.fonttype) #superscript font
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.top = None #flag for existence of toplevel#
self.matrix = matrix
self.matrices = matrices
self.materials = materials
self.mixing_models = ['Linear', 'None']
self.name = StringVar(value='Mixture') #matrix name
self.model = StringVar(value=self.mixing_models[0]) #model name
self.e = DoubleVar() #stores the porosity
self.rho = DoubleVar() #stores the bulk density
self.foc = DoubleVar() #stores the organic carbon fraction
self.components = [] #components
self.editflag = editflag
self.cancelflag = 0
if editflag == 1: #Detemine whether the chemical is added or edited
for component in self.matrix.components:
self.components.append(component.copy())
self.components[-1].name = StringVar(
value=self.components[-1].name)
self.components[-1].mfraction = DoubleVar(
value=self.components[-1].mfraction)
self.name.set(self.matrix.name)
self.model.set(self.matrix.model)
self.e.set(self.matrix.e)
self.rho.set(self.matrix.rho)
self.foc.set(self.matrix.foc)
def __init__(self, parent):
CtxSubPanel.__init__(self, parent)
b = TButton(self.panel,
command=self.makePageFrame,
style='Toolbutton',
image='context_add_page_frame')
tooltips.AddDescription(b, _('Add page frame'))
b.pack(side=LEFT)
b = TButton(self.panel,
command=self.addCenteredGuides,
style='Toolbutton',
image='context_add_centered_guides')
tooltips.AddDescription(b, _('Add guides for page center'))
b.pack(side=LEFT)
#############
b = TLabel(self.panel, image="toolbar_sep")
b.pack(side=LEFT)
b = TButton(self.panel,
command=self.addGuidesFrame,
style='Toolbutton',
image='context_add_guides_frame')
tooltips.AddDescription(b, _('Add guides across page border'))
b.pack(side=LEFT)
self.var_jump_number = DoubleVar(self.mw.root)
unit = config.preferences.default_unit
var_jump_unit = StringVar(self.mw.root)
self.var_jump = LengthVar(10, unit, self.var_jump_number,
var_jump_unit)
self.entry_jump = TSpinbox(self.panel,
var=0,
vartype=1,
textvariable=self.var_jump_number,
min=-1000,
max=1000,
step=5,
width=6,
command=self.addGuidesFrame)
self.entry_jump.pack(side=LEFT, padx=2)
config.preferences.Subscribe(CHANGED, self.update)
self.var_jump.set(0)
self.update(0, 0)
b = TLabel(self.panel, image="toolbar_sep")
b.pack(side=LEFT)
##############
b = TButton(self.panel,
command=self.removeAllGuides,
style='Toolbutton',
image='context_remove_all_guides')
tooltips.AddDescription(b, _('Remove all guides'))
b.pack(side=LEFT)
def addproduct(self):
self.products.append(Product(len(self.products) + 1))
self.products[-1].coef = DoubleVar(value=1)
self.products[-1].name = StringVar(value=self.chemical_list[0])
self.products[-1].formula = StringVar(value=self.formula_list[0])
self.products[-1].MW = StringVar(value=self.MW_list[0])
self.updatereaction()
def __init__(self, master, system, isotherm, coef):
"""Constructor method. Makes the GUI using the list of "Layer" objects
"layers." """
self.master = master
self.fonttype = system.fonttype
self.version = system.version
self.superfont = get_superfont(self.fonttype)
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.bgcolor = self.frame.cget('bg')
self.top = None
self.concunit = system.concunit
self.timeunit = system.timeunit
self.cinit = DoubleVar(value = coef[0])
self.qinit = DoubleVar(value = coef[1])
self.thalf = DoubleVar(value = coef[2])
self.ksorp = DoubleVar(value = coef[3])
self.coef = coef
self.isotherms = ['Linear--Kd specified', 'Linear--Kocfoc', 'Freundlich', 'Langmuir']
self.isotherm = isotherm
if self.isotherm == self.isotherms[0]:
self.Kd = coef[4]
if self.isotherm == self.isotherms[1]:
self.Kd = 10 ** coef[4]*coef[5]
if self.isotherm == self.isotherms[2]:
self.Kf = coef[4]
self.N = coef[5]
if self.isotherm == self.isotherms[3]:
self.qmax = coef[4]
self.b = coef[5]
self.epsilon = coef[6]
self.rho = coef[7]
def __init__(self, parent):
CtxSubPanel.__init__(self, parent)
self.radius1 = DoubleVar(self.mw.root, 0)
self.radius2 = DoubleVar(self.mw.root, 0)
label = TLabel(self.panel, image='context_rect_rx')
label.pack(side=LEFT, padx=2)
self.entry_radius1 = TSpinbox(self.panel,
var=0,
vartype=1,
textvariable=self.radius1,
min=0,
max=100,
step=1,
width=6,
command=self.applyRadius1)
self.entry_radius1.pack(side=LEFT, padx=2)
tooltips.AddDescription(self.entry_radius1,
_('Horizontal radius of rounded corners'))
#--------------
sep = FlatFrame(self.panel, width=4, height=2)
sep.pack(side=LEFT)
#--------------
label = TLabel(self.panel, image='context_rect_ry')
label.pack(side=LEFT, padx=2)
self.entry_radius2 = TSpinbox(self.panel,
var=0,
vartype=1,
textvariable=self.radius2,
min=0,
max=100,
step=1,
width=6,
command=self.applyRadius1)
self.entry_radius2.pack(side=LEFT, padx=2)
tooltips.AddDescription(self.entry_radius2,
_('Vertical radius of rounded corners'))
self.ReSubscribe()
def __init__(self, master, system, matrix):
"""Constructor method. Defines the parameters to be obtained in this
window."""
self.master = master
self.fonttype = system.fonttype
self.version = system.version
self.superfont = get_superfont(self.fonttype) #superscript font
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.top = None #flag for existence of toplevel#
self.matrix = matrix
self.name = StringVar(value=matrix.name) #stores the chemical name
self.model = StringVar(value=matrix.model) #stores the chemical name
self.e = DoubleVar(value=matrix.e) #stores the porosity
self.rho = DoubleVar(value=matrix.rho) #stores the bulk density
self.foc = DoubleVar(
value=matrix.foc) #stores the organic carbon fraction
self.cancelflag = 0
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
training_error_laber = Label(self, text='Training Error: ')
training_error_laber.pack(side='left')
error_options = [round(0.1 + i * 0.1, 2) for i in range(25)]
self.selected_error = DoubleVar(self, value=DEFAULT_TRAINING_ERROR)
option_menu = OptionMenu(self,
self.selected_error,
*error_options,
command=self._on_error_selection)
option_menu.pack(side='right')
def set_tk_var():
global method
method = StringVar()
method.set(read_config("Config", "Method", "str"))
global server
server = StringVar()
server.set(read_config("Config", "Server", "str"))
global shelltype
shelltype = StringVar()
shelltype.set(read_config("Config", "ShellType", "str"))
global parameter
parameter = StringVar()
parameter.set(read_config("Config", "Parameter", "str"))
global thread_num
thread_num = IntVar()
thread_num.set(read_config("Config", "ThreadNumber", "int"))
global req_delay
req_delay = DoubleVar()
req_delay.set(read_config("Config", "RequestDelay", "float"))
global time_out
time_out = DoubleVar()
time_out.set(read_config("Config", "RequestTimeout", "float"))
global random_ua
random_ua = BooleanVar()
random_ua.set(read_config("Config", "RandomUserAgent", "boolean"))
global con_close
con_close = BooleanVar()
con_close.set(read_config("Config", "ConnectionClose", "boolean"))
global keep_alive
keep_alive = BooleanVar()
keep_alive.set(read_config("Config", "KeepAlive0", "boolean"))
global custom_hdr
custom_hdr = BooleanVar()
custom_hdr.set(read_config("Config", "CustomRequestHeader", "boolean"))
global custom_hdr_data
custom_hdr_data = StringVar()
custom_hdr_data.set(read_config("Config", "CustomRequestHeaderData", "str"))
def init_ui(self):
self.parent.title('Fake Device')
self.style = Style()
self.style.theme_use('default')
self.pack(fill=BOTH, expand=1)
x_scale = Scale(self,
from_=self.MIN_X,
to=self.MAX_X,
command=self.on_scale_x)
x_scale.place(x=0, y=0)
y_scale = Scale(self,
from_=self.MIN_Y,
to=self.MAX_Y,
command=self.on_scale_y)
y_scale.place(x=0, y=20)
z_scale = Scale(self,
from_=self.MIN_Z,
to=self.MAX_Z,
command=self.on_scale_z)
z_scale.place(x=0, y=40)
angle_scale = Scale(self,
from_=0,
to=math.pi / 2,
command=self.on_scale_angle)
angle_scale.place(x=0, y=80)
self.x_var = IntVar()
self.x_label = Label(self, text=0, textvariable=self.x_var)
self.x_label.place(x=100, y=0)
self.y_var = IntVar()
self.y_label = Label(self, text=0, textvariable=self.y_var)
self.y_label.place(x=100, y=20)
self.z_var = IntVar()
self.z_label = Label(self, text=0, textvariable=self.z_var)
self.z_label.place(x=100, y=40)
self.angle_var = DoubleVar()
self.angle_label = Label(self, text=0, textvariable=self.angle_var)
self.angle_label.place(x=100, y=80)
self.button = Button(self, text='test', command=self.on_button)
self.button.place(x=0, y=100)
def __init__(self, master, system, database):
"""The constructor method."""
self.version = system.version
self.fonttype = system.fonttype
self.sfont = get_superfont(self.fonttype)
self.master = master
self.frame = Frame(master.frame)
self.tframe = Frame(master.tframe)
self.bframe = Frame(master.bframe)
self.tkfont = tkFont.Font(font=system.fonttype)
self.chemicals_list = database.keys()
self.chemicals_list.sort()
self.name = StringVar()
self.formula = StringVar()
self.MW = DoubleVar()
self.temp = DoubleVar(value=0)
self.Dw = DoubleVar(value=0)
self.Ref = StringVar(value=0)
self.Koc = DoubleVar(value=0)
self.Kdoc = DoubleVar(value=0)
self.Kf = DoubleVar(value=0)
self.N = DoubleVar(value=0)
self.importedchemicals = {}
for name in self.chemicals_list:
self.importedchemicals[name] = ChemicalData(name)
self.importedchemicals[name].read_database(database[name])
self.name_width = 10
self.ref_width = 10
for chemical_name in self.chemicals_list:
if (self.tkfont.measure(chemical_name) + 10) > self.name_width:
self.name_width = self.tkfont.measure(chemical_name) + 10
for temp in self.importedchemicals[chemical_name].temps:
if (self.tkfont.measure(
self.importedchemicals[chemical_name].Ref[temp]) +
10) > self.name_width:
self.name_width = self.tkfont.measure(
self.importedchemicals[chemical_name].Ref[temp]) + 10
if self.name_width < 150: self.name_width = 150
if self.ref_width < 150: self.ref_width = 150
self.cancelflag = 0
self.sname = StringVar(self.frame, value='')
def __init__(self, master=None, **kw):
apply(PatternFrame.__init__, (self, master), kw)
gradient = CreateSimpleGradient(StandardColors.white,
StandardColors.black)
frame = Frame(self)
frame.pack(side = TOP, fill = X)
self.var_gradient_type = IntVar(self)
for value, bitmap in [(0, 'linear'), (1, 'conical'), (2, 'radial')]:
bitmap = getattr(pixmaps, 'gradient_' + bitmap)
button = make_button(frame, bitmap = bitmap, value = value,
variable = self.var_gradient_type,
command = self.choose_type)
button.pack(side = LEFT, fill = X, expand = 1)
frame = Frame(self)
frame.pack(side = TOP, expand = 1, fill = X)
self.colors = [None, None]
self.colors[0] = ColorButton(frame, height = 1,
color = gradient.StartColor(),
command = self.set_color, args = 0)
self.colors[0].pack(side = LEFT, fill = X, expand = 1)
self.colors[1] = ColorButton(frame, height = 1,
color = gradient.EndColor(),
command = self.set_color, args = 1)
self.colors[1].pack(side = LEFT, fill = X, expand = 1)
self.var_border = DoubleVar(self)
self.var_border.set(0.0)
frame = Frame(self)
frame.pack(side = TOP, fill = X, expand = 1)
label = Label(frame, text = _("Border"))
label.pack(side = LEFT, expand = 1, anchor = E)
entry = MyEntry(frame, textvariable = self.var_border, width = 4,
justify = RIGHT, command = self.set_border)
entry.pack(side = LEFT, expand = 1, fill = X)
scroll = MiniScroller(frame, variable = self.var_border,
min = 0.0, max = 100.0, step = 1.0,
command = self.set_border)
scroll.pack(side = LEFT, fill = Y)
button = UpdatedButton(self, text = _("Edit Gradient"),
command = self.edit_gradient)
button.pack(side = TOP, fill = X)
pattern = LinearGradient(gradient)
self.SetPattern(pattern)
def init_tk(self, screen_name=None, geometry=None):
self.root = Tk(screenName=screen_name,
baseName=self.tk_basename,
className=self.tk_class_name)
app.root = self.root
from sk1.managers.uimanager import UIManager
app.uimanager = UIManager(self.root)
self.splash = SplashScreen(self.root)
self.splash.show()
self.splash.set_val(.1, 'DialogManager initialization...')
from sk1.managers.dialogmanager import DialogManager
app.dialogman = DialogManager(self.root)
self.splash.set_val(.15, 'Setting appication data...')
app.info1 = StringVar(self.root, '')
app.info2 = StringVar(self.root, '')
app.info3 = DoubleVar(self.root, 0)
# Reset locale again to make sure we get properly translated
# messages if desired by the user. For some reason it may
# have been reset by Tcl/Tk.
# if this fails it will already have failed in
# app/__init__.py which also prints a warning.
try:
import locale
except ImportError:
pass
else:
try:
locale.setlocale(locale.LC_MESSAGES, "")
except:
pass
if not geometry:
# try to read geometry from resource database
geometry = self.root.option_get('geometry', 'Geometry')
if geometry:
try:
self.root.geometry(geometry)
except TclError:
sys.stderr.write('%s: invalid geometry specification %s' %
(self.tk_basename, geometry))
def create_length_widgets(top, master, command):
var_number = DoubleVar(top)
var_unit = StringVar(top)
var_length = LengthVar(1.0,
config.preferences.default_unit,
var_number,
var_unit,
command=command)
entry = TSpinbox(master,
textvariable=var_number,
vartype=1,
min=0,
max=50000,
step=.1,
width=6,
command=var_length.UpdateNumber)
unitlabel = UnitLabel(master)
return var_length, entry, unitlabel
def __init__(self, master, version, fonttype, timeunit, chemicals,
kdecays):
"""Constructor method."""
self.version = version
self.fonttype = fonttype
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.superfont = get_superfont(self.fonttype)
self.cancelflag = 0
self.timeunit = timeunit
self.chemicals = chemicals
self.kdecays = []
for n in range(len(self.chemicals)):
self.kdecays.append(DoubleVar(value=kdecays[n]))
def init_widgets(self):
self.content_wrapper = Frame(self)
self.content_wrapper.configure(bg="white")
self.screen_title = Header1Label(self.content_wrapper)
self.empty_space_1 = PLabel(self.content_wrapper)
self.progress_bar_control_var = DoubleVar()
self.progress_bar = Progressbar(self.content_wrapper,
orient=HORIZONTAL,
mode="determinate",
length=WINDOW_WIDTH / 2,
variable=self.progress_bar_control_var)
self.wait_text = PLabel(self.content_wrapper)
self.information_display = PLabel(self.content_wrapper)
self.empty_space_2 = PLabel(self.content_wrapper)
self.next_button = Button(self.content_wrapper,
text="Next",
state=DISABLED,
command=lambda: self.on_next_button())
