def protect_parameter(self, param, state=True):
""" Protect the named parameter.
Protecting is not a real lock, it just marks the parameter a list of
"protected" parameters. This is typically used to mark values that have
been set manually by the user (using the ControllerWidget for instance)
and that should not be later modified by automatic parameters tweaking
(such as completion systems).
Protected parameters are listed in an additional trait,
"protected_parameters".
If the "state" parameter is False, then we will unprotect it
(calling unprotect_parameter())
"""
if not state:
return self.unprotect_parameter(param)
if not self.trait('protected_parameters'):
# add a 'protected_parameters' trait bypassing the
# Controller.add_trait mechanism (it will not be a "user_trait")
HasTraits.add_trait(self, 'protected_parameters',
traits.List(traits.Str(), default=[],
hidden=True))
#self.locked_parameters = []
protected = set(self.protected_parameters)
protected.update([param])
self.protected_parameters = sorted(protected)
def import_from_dict(self, state_dict, clear=False):
""" Set Controller variables from a dictionary. When setting values on
Controller instances (in the Controller sub-tree), replace dictionaries
by Controller instances appropriately.
Parameters
----------
state_dict: dict, sorted_dictionary or OrderedDict
dict containing the variables to set
clear: bool (optional, default: False)
if True, older values (in keys not listed in state_dict) will be
cleared, otherwise they are left in place.
"""
if clear:
for trait_name in self.user_traits():
if trait_name not in state_dict:
delattr(self, trait_name)
for trait_name, value in six.iteritems(state_dict):
trait = self.trait(trait_name)
if trait_name == 'protected_parameters' and trait is None:
HasTraits.add_trait(self, 'protected_parameters',
traits.List(traits.Str(), default=[],
hidden=True))
trait = self.trait('protected_parameters')
if trait is None and not isinstance(self, OpenKeyController):
raise KeyError(
"item %s is not a trait in the Controller" % trait_name)
if isinstance(trait.trait_type, Instance) \
and issubclass(trait.trait_type.klass, Controller):
controller = trait.trait_type.create_default_value(
trait.trait_type.klass)
controller.import_from_dict(value)
else:
if value in (None, Undefined):
# None / Undefined may be an acceptable value for many
# traits types
try:
setattr(self, trait_name, value)
except traits.TraitError:
if value is not Undefined:
setattr(self, trait_name, Undefined)
else:
# check trait type for conversions
tr = self.trait(trait_name)
if tr and isinstance(tr.trait_type, Set):
setattr(self, trait_name, set(value))
elif tr and isinstance(tr.trait_type, Tuple):
setattr(self, trait_name, tuple(value))
else:
setattr(self, trait_name, value)
def copy(self, with_values=True):
""" Copy traits definitions to a new Controller object
Parameters
----------
with_values: bool (optional, default: False)
if True, traits values will be copied, otherwise the defaut trait
value will be left in the copy.
Returns
-------
copied: Controller instance
the returned copy will have the same class as the copied object
(which may be a derived class from Controller). Traits definitions
will be copied. Traits values will only be copied if with_values is
True.
"""
import copy
initargs = ()
if hasattr(self, '__getinitargs__'):
# if the Controller class is subclassed and needs init parameters
initargs = self.__getinitargs__()
copied = self.__class__(*initargs)
for name, trait in six.iteritems(self.user_traits()):
copied.add_trait(name, self._clone_trait(trait))
if with_values:
setattr(copied, name, getattr(self, name))
if self.trait('protected_parameters'):
trait = self.trait('protected_parameters')
HasTraits.add_trait(copied, 'protected_parameters',
self._clone_trait(trait))
if with_values:
setattr(copied, 'protected_parameters',
getattr(self, 'protected_parameters'))
return copied
#class TestClass(HasTraits):
# b1 = Bool
# b2 = Bool
# b3 = Bool
# _updated = Bool(False)
#
#for e in dir(view1):
# print e
#for attr in ['b1', "title", "handler", "buttons"]:
# print attr, getattr(view1, attr, None)
#tc = TestClass()
#tc.add_trait( 'b4',Bool)
t = HasTraits()
nameL = []
for i in range(4):
name = 'r%d' % i
t.add_trait(name, Range(1, 10, i))
nameL.append(name)
view1 = View(nameL,
title="Alter Title",
handler=TC_Handler(),
buttons=['OK', 'Cancel'])
t.configure_traits(view=view1)
#class TestClass(HasTraits):
# b1 = Bool
# b2 = Bool
# b3 = Bool
# _updated = Bool(False)
#
#for e in dir(view1):
# print e
#for attr in ['b1', "title", "handler", "buttons"]:
# print attr, getattr(view1, attr, None)
#tc = TestClass()
#tc.add_trait( 'b4',Bool)
t = HasTraits()
nameL = []
for i in range(4):
name = 'r%d'%i
t.add_trait(name, Range(1,10,i) )
nameL.append(name)
view1 = View(nameL,
title="Alter Title",
handler=TC_Handler(),
buttons = ['OK', 'Cancel'])
t.configure_traits(view=view1)
