def __init__(self, entry, engine, type_name='', type_class=None):
if type_class != TypeClass.ANY and type_class != TypeClass.SEQUENCE:
pass
elif entry:
ttype = engine.get_type(entry)
type_name = ttype.getName()
type_class = ttype.getTypeClass()
self.typeName = type_name
self.typeClass = type_class
self.Name = type_name
self.TypeClass = type_class
if self.Name.startswith('[]'):
# for simple type
comp_type_class = TypeClassGroups.get_type_class(self.Name[2:])
if not comp_type_class:
# interface, struct, enum and ...
comp_idl_class = engine.for_name(self.Name[2:])
if comp_idl_class:
comp_type_class = comp_idl_class.getTypeClass()
elif comp_type_class == TypeClass.ANY:
if entry.target != None and len(entry.target) > 0:
comp_idl_class = engine.reflection.getType(entry.target[0])
if entry and entry.target != None and isinstance(entry.target, tuple) and len(entry.target) > 0:
elemental_entry = EntryBase(None, entry.target[0])
self.ComponentType = ExtType2(elemental_entry, engine, self.Name[2:], comp_type_class)
else:
self.ComponentType = ExtType2(None, engine, self.Name[2:], comp_type_class)
else:
self.ComponentType = None
def __init__(self, entry, engine, type_name='', type_class=None):
if type_class != TypeClass.ANY and type_class != TypeClass.SEQUENCE:
pass
elif entry:
ttype = engine.get_type(entry)
type_name = ttype.getName()
type_class = ttype.getTypeClass()
self.typeName = type_name
self.typeClass = type_class
self.Name = type_name
self.TypeClass = type_class
if self.Name.startswith('[]'):
# for simple type
comp_type_class = TypeClassGroups.get_type_class(self.Name[2:])
if not comp_type_class:
# interface, struct, enum and ...
comp_idl_class = engine.for_name(self.Name[2:])
if comp_idl_class:
comp_type_class = comp_idl_class.getTypeClass()
elif comp_type_class == TypeClass.ANY:
if entry.target != None and len(entry.target) > 0:
comp_idl_class = engine.reflection.getType(entry.target[0])
if entry and entry.target != None and isinstance(
entry.target, tuple) and len(entry.target) > 0:
elemental_entry = EntryBase(None, entry.target[0])
self.ComponentType = ExtType2(elemental_entry, engine,
self.Name[2:], comp_type_class)
else:
self.ComponentType = ExtType2(None, engine, self.Name[2:],
comp_type_class)
else:
self.ComponentType = None
def get_arguments(self, method):
"""used for callback to get argument."""
if not method: raise Exception('illeagal method.')
p_infos = method.getParameterInfos()
n_infos = len(p_infos)
method_name = method.getName()
if n_infos == 0:
return ()
elif n_infos == 1:
if method_name in ('getByIndex', 'getByName', 'getAccessibleChild', 'getByIdentifier'):
state = False
try:
state, arg, ttype, key = self.get_arguments_for_special_methods(method)
except Exception as e:
print(e)
traceback.print_exc()
if state:
return (arg, )
# check all arguments
for param in p_infos:
if not param.aMode == ParamMode.IN:
raise Exception('unable to get arguments from input.')
state = 0
try:
method_args = []
elements = []
for param in p_infos:
arg = '%s %s %s' % (
self.engine.get_mode_string(param.aMode), param.aType.Name, param.aName)
elements.append((arg, param.aType.getTypeClass().value))
method_args.append(arg)
state, results = self.dlgs.dialog_elemental_input(
elements, 'input arguments', "%s(\n\t%s\n )" % (method_name, ", \n\t".join(method_args)),
(method.getDeclaringClass().getName(), method_name))
except Exception as e:
print(e)
if not state: raise CancelException("canceled.")
args = []
for param, result in zip(p_infos, results):
type_class = param.aType.getTypeClass()
if type_class in (TypeClass.INTERFACE, TypeClass.STRUCT, TypeClass.SEQUENCE):
args.append(result.value)
else:
type_name = param.aType.getName()
value_type = result.value_type
value = result.value
if type_class == TypeClass.ANY:
type_class = TypeClassGroups.get_type_class(value_type)
if value_type == "ENUM":
type_name, value = self.engine.split_enum_name(value)
else:
type_class = param.aType.getTypeClass()
args.append(
self.engine.get_value(value, type_name, type_class))
return args
def make_single_value(self, name, type_name, type_class, doc=None, add_doc=None):
""" """
elements = ((name, type_class.value),)
try:
text = "%s %s" % (type_name, name)
if add_doc: text += "\n" + add_doc
# ToDo add information about enum if type_class is ENUM
state, results = self.dlgs.dialog_elemental_input(
elements, 'input value', text, doc)
except Exception as e:
print(e)
if not state: raise CancelException("canceled.")
result = results[0]
value = result.value
if type_class == TypeClass.ANY:
type_class = TypeClassGroups.get_type_class(result.value_type)
type_name = result.value_type
if value_type == "ENUM":
type_name, value = self.engine.split_enum_name(result.value)
return self.engine.get_value(value, type_name, type_class)
