# This file was created automatically by SWIG.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

import _hk_classes

def _swig_setattr(self,class_type,name,value):
    if (name == "this"):
        if isinstance(value, class_type):
            self.__dict__[name] = value.this
            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
            del value.thisown
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    self.__dict__[name] = value

def _swig_getattr(self,class_type,name):
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


ft_table = _hk_classes.ft_table
ft_query = _hk_classes.ft_query
ft_form = _hk_classes.ft_form
ft_report = _hk_classes.ft_report
ft_view = _hk_classes.ft_view
lt_table = _hk_classes.lt_table
lt_query = _hk_classes.lt_query
lt_form = _hk_classes.lt_form
lt_report = _hk_classes.lt_report
lt_index = _hk_classes.lt_index
lt_view = _hk_classes.lt_view
ot_database = _hk_classes.ot_database
ot_table = _hk_classes.ot_table
ot_query = _hk_classes.ot_query
ot_form = _hk_classes.ot_form
ot_report = _hk_classes.ot_report
ot_view = _hk_classes.ot_view
dt_table = _hk_classes.dt_table
dt_query = _hk_classes.dt_query
dt_view = _hk_classes.dt_view

is_numerictype = _hk_classes.is_numerictype

is_integertype = _hk_classes.is_integertype

is_realtype = _hk_classes.is_realtype

inch2cm = _hk_classes.inch2cm

cm2inch = _hk_classes.cm2inch
class dependingclass(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, dependingclass, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, dependingclass, name)
    def __repr__(self):
        return "<C dependingclass instance at %s>" % (self.this,)
    __swig_setmethods__["dependingfield"] = _hk_classes.dependingclass_dependingfield_set
    __swig_getmethods__["dependingfield"] = _hk_classes.dependingclass_dependingfield_get
    if _newclass:dependingfield = property(_hk_classes.dependingclass_dependingfield_get, _hk_classes.dependingclass_dependingfield_set)
    __swig_setmethods__["masterfield"] = _hk_classes.dependingclass_masterfield_set
    __swig_getmethods__["masterfield"] = _hk_classes.dependingclass_masterfield_get
    if _newclass:masterfield = property(_hk_classes.dependingclass_masterfield_get, _hk_classes.dependingclass_masterfield_set)
    def __init__(self, *args):
        _swig_setattr(self, dependingclass, 'this', _hk_classes.new_dependingclass(*args))
        _swig_setattr(self, dependingclass, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_dependingclass):
        try:
            if self.thisown: destroy(self)
        except: pass

class dependingclassPtr(dependingclass):
    def __init__(self, this):
        _swig_setattr(self, dependingclass, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, dependingclass, 'thisown', 0)
        _swig_setattr(self, dependingclass,self.__class__,dependingclass)
_hk_classes.dependingclass_swigregister(dependingclassPtr)

class referentialclass(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, referentialclass, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, referentialclass, name)
    def __repr__(self):
        return "<C referentialclass instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, referentialclass, 'this', _hk_classes.new_referentialclass(*args))
        _swig_setattr(self, referentialclass, 'thisown', 1)
    __swig_setmethods__["p_name"] = _hk_classes.referentialclass_p_name_set
    __swig_getmethods__["p_name"] = _hk_classes.referentialclass_p_name_get
    if _newclass:p_name = property(_hk_classes.referentialclass_p_name_get, _hk_classes.referentialclass_p_name_set)
    __swig_setmethods__["p_masterdatasource"] = _hk_classes.referentialclass_p_masterdatasource_set
    __swig_getmethods__["p_masterdatasource"] = _hk_classes.referentialclass_p_masterdatasource_get
    if _newclass:p_masterdatasource = property(_hk_classes.referentialclass_p_masterdatasource_get, _hk_classes.referentialclass_p_masterdatasource_set)
    __swig_setmethods__["p_fields"] = _hk_classes.referentialclass_p_fields_set
    __swig_getmethods__["p_fields"] = _hk_classes.referentialclass_p_fields_get
    if _newclass:p_fields = property(_hk_classes.referentialclass_p_fields_get, _hk_classes.referentialclass_p_fields_set)
    __swig_setmethods__["p_deletecascade"] = _hk_classes.referentialclass_p_deletecascade_set
    __swig_getmethods__["p_deletecascade"] = _hk_classes.referentialclass_p_deletecascade_get
    if _newclass:p_deletecascade = property(_hk_classes.referentialclass_p_deletecascade_get, _hk_classes.referentialclass_p_deletecascade_set)
    __swig_setmethods__["p_updatecascade"] = _hk_classes.referentialclass_p_updatecascade_set
    __swig_getmethods__["p_updatecascade"] = _hk_classes.referentialclass_p_updatecascade_get
    if _newclass:p_updatecascade = property(_hk_classes.referentialclass_p_updatecascade_get, _hk_classes.referentialclass_p_updatecascade_set)
    def __del__(self, destroy=_hk_classes.delete_referentialclass):
        try:
            if self.thisown: destroy(self)
        except: pass

class referentialclassPtr(referentialclass):
    def __init__(self, this):
        _swig_setattr(self, referentialclass, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, referentialclass, 'thisown', 0)
        _swig_setattr(self, referentialclass,self.__class__,referentialclass)
_hk_classes.referentialclass_swigregister(referentialclassPtr)

class hk_string(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_string, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, hk_string, name)
    def __repr__(self):
        return "<C std::vector<(hk_string)> instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_string, 'this', _hk_classes.new_hk_string(*args))
        _swig_setattr(self, hk_string, 'thisown', 1)
    def __len__(*args): return _hk_classes.hk_string___len__(*args)
    def clear(*args): return _hk_classes.hk_string_clear(*args)
    def append(*args): return _hk_classes.hk_string_append(*args)
    def __nonzero__(*args): return _hk_classes.hk_string___nonzero__(*args)
    def pop(*args): return _hk_classes.hk_string_pop(*args)
    def __getitem__(*args): return _hk_classes.hk_string___getitem__(*args)
    def __getslice__(*args): return _hk_classes.hk_string___getslice__(*args)
    def __setitem__(*args): return _hk_classes.hk_string___setitem__(*args)
    def __setslice__(*args): return _hk_classes.hk_string___setslice__(*args)
    def __delitem__(*args): return _hk_classes.hk_string___delitem__(*args)
    def __delslice__(*args): return _hk_classes.hk_string___delslice__(*args)
    def __del__(self, destroy=_hk_classes.delete_hk_string):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_stringPtr(hk_string):
    def __init__(self, this):
        _swig_setattr(self, hk_string, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_string, 'thisown', 0)
        _swig_setattr(self, hk_string,self.__class__,hk_string)
_hk_classes.hk_string_swigregister(hk_stringPtr)


smallstringconversion = _hk_classes.smallstringconversion

l2u = _hk_classes.l2u

u2l = _hk_classes.u2l

string2upper = _hk_classes.string2upper

string2lower = _hk_classes.string2lower

localestring2double = _hk_classes.localestring2double

localestring2int = _hk_classes.localestring2int

localestring2uint = _hk_classes.localestring2uint

standardstring2double = _hk_classes.standardstring2double

longint2string = _hk_classes.longint2string

ulongint2string = _hk_classes.ulongint2string

replace_all = _hk_classes.replace_all

trimleft = _hk_classes.trimleft

trimright = _hk_classes.trimright

trim = _hk_classes.trim

int2hex = _hk_classes.int2hex
class hk_class(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_class, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, hk_class, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C hk_class instance at %s>" % (self.this,)
    noninteractive = _hk_classes.hk_class_noninteractive
    interactive = _hk_classes.hk_class_interactive
    __swig_getmethods__["show_warningmessage"] = lambda x: _hk_classes.hk_class_show_warningmessage
    if _newclass:show_warningmessage = staticmethod(_hk_classes.hk_class_show_warningmessage)
    __swig_getmethods__["hk_translate"] = lambda x: _hk_classes.hk_class_hk_translate
    if _newclass:hk_translate = staticmethod(_hk_classes.hk_class_hk_translate)
    __swig_getmethods__["show_yesnodialog"] = lambda x: _hk_classes.hk_class_show_yesnodialog
    if _newclass:show_yesnodialog = staticmethod(_hk_classes.hk_class_show_yesnodialog)
    __swig_getmethods__["show_stringvaluedialog"] = lambda x: _hk_classes.hk_class_show_stringvaluedialog
    if _newclass:show_stringvaluedialog = staticmethod(_hk_classes.hk_class_show_stringvaluedialog)
    __swig_getmethods__["save_preferences"] = lambda x: _hk_classes.hk_class_save_preferences
    if _newclass:save_preferences = staticmethod(_hk_classes.hk_class_save_preferences)

class hk_classPtr(hk_class):
    def __init__(self, this):
        _swig_setattr(self, hk_class, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_class, 'thisown', 0)
        _swig_setattr(self, hk_class,self.__class__,hk_class)
_hk_classes.hk_class_swigregister(hk_classPtr)

format_number = _hk_classes.format_number

format_standard_number = _hk_classes.format_standard_number

hk_class_show_warningmessage = _hk_classes.hk_class_show_warningmessage

hk_class_hk_translate = _hk_classes.hk_class_hk_translate

hk_class_show_yesnodialog = _hk_classes.hk_class_show_yesnodialog

hk_class_show_stringvaluedialog = _hk_classes.hk_class_show_stringvaluedialog

hk_class_save_preferences = _hk_classes.hk_class_save_preferences

class hk_connection(hk_class):
    __swig_setmethods__ = {}
    for _s in [hk_class]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_connection, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_class]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_connection, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C hk_connection instance at %s>" % (self.this,)
    def __del__(self, destroy=_hk_classes.delete_hk_connection):
        try:
            if self.thisown: destroy(self)
        except: pass
    def set_host(*args): return _hk_classes.hk_connection_set_host(*args)
    def host(*args): return _hk_classes.hk_connection_host(*args)
    def set_user(*args): return _hk_classes.hk_connection_set_user(*args)
    def user(*args): return _hk_classes.hk_connection_user(*args)
    def set_password(*args): return _hk_classes.hk_connection_set_password(*args)
    def set_tcp_port(*args): return _hk_classes.hk_connection_set_tcp_port(*args)
    def tcp_port(*args): return _hk_classes.hk_connection_tcp_port(*args)
    def default_tcp_port(*args): return _hk_classes.hk_connection_default_tcp_port(*args)
    def connect(*args): return _hk_classes.hk_connection_connect(*args)
    def disconnect(*args): return _hk_classes.hk_connection_disconnect(*args)
    def is_connected(*args): return _hk_classes.hk_connection_is_connected(*args)
    def dblist(*args): return _hk_classes.hk_connection_dblist(*args)
    def new_database(*args): return _hk_classes.hk_connection_new_database(*args)
    def create_database(*args): return _hk_classes.hk_connection_create_database(*args)
    def delete_database(*args): return _hk_classes.hk_connection_delete_database(*args)
    def database_exists(*args): return _hk_classes.hk_connection_database_exists(*args)
    def drivermanager(*args): return _hk_classes.hk_connection_drivermanager(*args)

class hk_connectionPtr(hk_connection):
    def __init__(self, this):
        _swig_setattr(self, hk_connection, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_connection, 'thisown', 0)
        _swig_setattr(self, hk_connection,self.__class__,hk_connection)
_hk_classes.hk_connection_swigregister(hk_connectionPtr)

class hk_drivermanager(hk_class):
    __swig_setmethods__ = {}
    for _s in [hk_class]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_drivermanager, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_class]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_drivermanager, name)
    def __repr__(self):
        return "<C hk_drivermanager instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_drivermanager, 'this', _hk_classes.new_hk_drivermanager(*args))
        _swig_setattr(self, hk_drivermanager, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_drivermanager):
        try:
            if self.thisown: destroy(self)
        except: pass
    def driverlist(*args): return _hk_classes.hk_drivermanager_driverlist(*args)
    def new_connection(*args): return _hk_classes.hk_drivermanager_new_connection(*args)
    def find_existing_connection(*args): return _hk_classes.hk_drivermanager_find_existing_connection(*args)
    __swig_getmethods__["show_driverselectdialog"] = lambda x: _hk_classes.hk_drivermanager_show_driverselectdialog
    if _newclass:show_driverselectdialog = staticmethod(_hk_classes.hk_drivermanager_show_driverselectdialog)
    __swig_getmethods__["set_path"] = lambda x: _hk_classes.hk_drivermanager_set_path
    if _newclass:set_path = staticmethod(_hk_classes.hk_drivermanager_set_path)
    __swig_getmethods__["path"] = lambda x: _hk_classes.hk_drivermanager_path
    if _newclass:path = staticmethod(_hk_classes.hk_drivermanager_path)

class hk_drivermanagerPtr(hk_drivermanager):
    def __init__(self, this):
        _swig_setattr(self, hk_drivermanager, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_drivermanager, 'thisown', 0)
        _swig_setattr(self, hk_drivermanager,self.__class__,hk_drivermanager)
_hk_classes.hk_drivermanager_swigregister(hk_drivermanagerPtr)

hk_drivermanager_show_driverselectdialog = _hk_classes.hk_drivermanager_show_driverselectdialog

hk_drivermanager_set_path = _hk_classes.hk_drivermanager_set_path

hk_drivermanager_path = _hk_classes.hk_drivermanager_path

class hk_database(hk_class):
    __swig_setmethods__ = {}
    for _s in [hk_class]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_database, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_class]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_database, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C hk_database instance at %s>" % (self.this,)
    def tablelist(*args): return _hk_classes.hk_database_tablelist(*args)
    def querylist(*args): return _hk_classes.hk_database_querylist(*args)
    def formlist(*args): return _hk_classes.hk_database_formlist(*args)
    def reportlist(*args): return _hk_classes.hk_database_reportlist(*args)
    def viewlist(*args): return _hk_classes.hk_database_viewlist(*args)
    def tableviewlist(*args): return _hk_classes.hk_database_tableviewlist(*args)
    def new_table(*args): return _hk_classes.hk_database_new_table(*args)
    def new_resultquery(*args): return _hk_classes.hk_database_new_resultquery(*args)
    def new_view(*args): return _hk_classes.hk_database_new_view(*args)
    def new_actionquery(*args): return _hk_classes.hk_database_new_actionquery(*args)
    def load_datasource(*args): return _hk_classes.hk_database_load_datasource(*args)
    def delete_table(*args): return _hk_classes.hk_database_delete_table(*args)
    def table_exists(*args): return _hk_classes.hk_database_table_exists(*args)
    def query_exists(*args): return _hk_classes.hk_database_query_exists(*args)
    def view_exists(*args): return _hk_classes.hk_database_view_exists(*args)
    def load(*args): return _hk_classes.hk_database_load(*args)
    def save(*args): return _hk_classes.hk_database_save(*args)
    def connection(*args): return _hk_classes.hk_database_connection(*args)
    def new_formvisible(*args): return _hk_classes.hk_database_new_formvisible(*args)
    def new_reportvisible(*args): return _hk_classes.hk_database_new_reportvisible(*args)
    def new_tablevisible(*args): return _hk_classes.hk_database_new_tablevisible(*args)
    def new_queryvisible(*args): return _hk_classes.hk_database_new_queryvisible(*args)
    central = _hk_classes.hk_database_central
    local = _hk_classes.hk_database_local
    def set_storagemode(*args): return _hk_classes.hk_database_set_storagemode(*args)
    def storagemode(*args): return _hk_classes.hk_database_storagemode(*args)
    def loadmode(*args): return _hk_classes.hk_database_loadmode(*args)
    def create_centralstoragetable(*args): return _hk_classes.hk_database_create_centralstoragetable(*args)
    def has_centralstoragetable(*args): return _hk_classes.hk_database_has_centralstoragetable(*args)
    def load_local(*args): return _hk_classes.hk_database_load_local(*args)
    def load_central(*args): return _hk_classes.hk_database_load_central(*args)
    def save_local(*args): return _hk_classes.hk_database_save_local(*args)
    def save_central(*args): return _hk_classes.hk_database_save_central(*args)
    def delete_localfile(*args): return _hk_classes.hk_database_delete_localfile(*args)
    def delete_centralfile(*args): return _hk_classes.hk_database_delete_centralfile(*args)
    def filelist(*args): return _hk_classes.hk_database_filelist(*args)
    def local_filelist(*args): return _hk_classes.hk_database_local_filelist(*args)
    def central_filelist(*args): return _hk_classes.hk_database_central_filelist(*args)
    def save_configuration(*args): return _hk_classes.hk_database_save_configuration(*args)
    def disable(*args): return _hk_classes.hk_database_disable(*args)
    def existing_presentation(*args): return _hk_classes.hk_database_existing_presentation(*args)
    def existing_form(*args): return _hk_classes.hk_database_existing_form(*args)
    def existing_report(*args): return _hk_classes.hk_database_existing_report(*args)
    def set_name(*args): return _hk_classes.hk_database_set_name(*args)
    def name(*args): return _hk_classes.hk_database_name(*args)

class hk_databasePtr(hk_database):
    def __init__(self, this):
        _swig_setattr(self, hk_database, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_database, 'thisown', 0)
        _swig_setattr(self, hk_database,self.__class__,hk_database)
_hk_classes.hk_database_swigregister(hk_databasePtr)

class hk_data(hk_class):
    __swig_setmethods__ = {}
    for _s in [hk_class]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_data, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_class]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_data, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C hk_data instance at %s>" % (self.this,)
    def name(*args): return _hk_classes.hk_data_name(*args)
    def set_name(*args): return _hk_classes.hk_data_set_name(*args)

class hk_dataPtr(hk_data):
    def __init__(self, this):
        _swig_setattr(self, hk_data, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_data, 'thisown', 0)
        _swig_setattr(self, hk_data,self.__class__,hk_data)
_hk_classes.hk_data_swigregister(hk_dataPtr)

class hk_datasource(hk_data):
    __swig_setmethods__ = {}
    for _s in [hk_data]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_datasource, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_data]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_datasource, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C hk_datasource instance at %s>" % (self.this,)
    def name(*args): return _hk_classes.hk_datasource_name(*args)
    def set_name(*args): return _hk_classes.hk_datasource_set_name(*args)
    def set_sql(*args): return _hk_classes.hk_datasource_set_sql(*args)
    def sql(*args): return _hk_classes.hk_datasource_sql(*args)
    def is_rawsql(*args): return _hk_classes.hk_datasource_is_rawsql(*args)
    def goto_row(*args): return _hk_classes.hk_datasource_goto_row(*args)
    def goto_first(*args): return _hk_classes.hk_datasource_goto_first(*args)
    def goto_last(*args): return _hk_classes.hk_datasource_goto_last(*args)
    def goto_next(*args): return _hk_classes.hk_datasource_goto_next(*args)
    def goto_previous(*args): return _hk_classes.hk_datasource_goto_previous(*args)
    def row_position(*args): return _hk_classes.hk_datasource_row_position(*args)
    def max_rows(*args): return _hk_classes.hk_datasource_max_rows(*args)
    def enable(*args): return _hk_classes.hk_datasource_enable(*args)
    def disable(*args): return _hk_classes.hk_datasource_disable(*args)
    def set_enabled(*args): return _hk_classes.hk_datasource_set_enabled(*args)
    def is_enabled(*args): return _hk_classes.hk_datasource_is_enabled(*args)
    def column_by_name(*args): return _hk_classes.hk_datasource_column_by_name(*args)
    def store_changed_data(*args): return _hk_classes.hk_datasource_store_changed_data(*args)
    def set_automatic_data_update(*args): return _hk_classes.hk_datasource_set_automatic_data_update(*args)
    def is_automatic_data_update(*args): return _hk_classes.hk_datasource_is_automatic_data_update(*args)
    mode_normal = _hk_classes.hk_datasource_mode_normal
    mode_createtable = _hk_classes.hk_datasource_mode_createtable
    mode_altertable = _hk_classes.hk_datasource_mode_altertable
    mode_disabled = _hk_classes.hk_datasource_mode_disabled
    mode_insertrow = _hk_classes.hk_datasource_mode_insertrow
    mode_deleterow = _hk_classes.hk_datasource_mode_deleterow
    mode_unknown = _hk_classes.hk_datasource_mode_unknown
    def mode(*args): return _hk_classes.hk_datasource_mode(*args)
    def setmode_insertrow(*args): return _hk_classes.hk_datasource_setmode_insertrow(*args)
    def delete_actualrow(*args): return _hk_classes.hk_datasource_delete_actualrow(*args)
    def delete_rows(*args): return _hk_classes.hk_datasource_delete_rows(*args)
    def setmode_normal(*args): return _hk_classes.hk_datasource_setmode_normal(*args)
    def setmode_createtable(*args): return _hk_classes.hk_datasource_setmode_createtable(*args)
    def setmode_altertable(*args): return _hk_classes.hk_datasource_setmode_altertable(*args)
    def new_column(*args): return _hk_classes.hk_datasource_new_column(*args)
    def alter_column(*args): return _hk_classes.hk_datasource_alter_column(*args)
    def delete_column(*args): return _hk_classes.hk_datasource_delete_column(*args)
    def create_table_now(*args): return _hk_classes.hk_datasource_create_table_now(*args)
    def alter_table_now(*args): return _hk_classes.hk_datasource_alter_table_now(*args)
    standard = _hk_classes.hk_datasource_standard
    batchread = _hk_classes.hk_datasource_batchread
    batchwrite = _hk_classes.hk_datasource_batchwrite
    def set_accessmode(*args): return _hk_classes.hk_datasource_set_accessmode(*args)
    def accessmode(*args): return _hk_classes.hk_datasource_accessmode(*args)
    def is_readonly(*args): return _hk_classes.hk_datasource_is_readonly(*args)
    def set_readonly(*args): return _hk_classes.hk_datasource_set_readonly(*args)
    def drop_index(*args): return _hk_classes.hk_datasource_drop_index(*args)
    def create_index(*args): return _hk_classes.hk_datasource_create_index(*args)
    def alter_index(*args): return _hk_classes.hk_datasource_alter_index(*args)
    def database(*args): return _hk_classes.hk_datasource_database(*args)
    def set_filter(*args): return _hk_classes.hk_datasource_set_filter(*args)
    def filter(*args): return _hk_classes.hk_datasource_filter(*args)
    def set_temporaryfilter(*args): return _hk_classes.hk_datasource_set_temporaryfilter(*args)
    def temporaryfilter(*args): return _hk_classes.hk_datasource_temporaryfilter(*args)
    def set_use_temporaryfilter(*args): return _hk_classes.hk_datasource_set_use_temporaryfilter(*args)
    def use_temporaryfilter(*args): return _hk_classes.hk_datasource_use_temporaryfilter(*args)
    def clear_filter(*args): return _hk_classes.hk_datasource_clear_filter(*args)
    def set_sorting(*args): return _hk_classes.hk_datasource_set_sorting(*args)
    def sorting(*args): return _hk_classes.hk_datasource_sorting(*args)
    def set_temporarysorting(*args): return _hk_classes.hk_datasource_set_temporarysorting(*args)
    def temporarysorting(*args): return _hk_classes.hk_datasource_temporarysorting(*args)
    def set_use_temporarysorting(*args): return _hk_classes.hk_datasource_set_use_temporarysorting(*args)
    def use_temporarysorting(*args): return _hk_classes.hk_datasource_use_temporarysorting(*args)
    def clear_sorting(*args): return _hk_classes.hk_datasource_clear_sorting(*args)
    def datasource_used(*args): return _hk_classes.hk_datasource_datasource_used(*args)
    def referenceslist(*args): return _hk_classes.hk_datasource_referenceslist(*args)
    def add_reference(*args): return _hk_classes.hk_datasource_add_reference(*args)
    def drop_reference(*args): return _hk_classes.hk_datasource_drop_reference(*args)
    def has_changed(*args): return _hk_classes.hk_datasource_has_changed(*args)
    def columnlist(*args): return _hk_classes.hk_datasource_columnlist(*args)
    def indexlist(*args): return _hk_classes.hk_datasource_indexlist(*args)
    def show_currentrow(*args): return _hk_classes.hk_datasource_show_currentrow(*args)
    def indices(*args): return _hk_classes.hk_datasource_indices(*args)
    def __del__(self, destroy=_hk_classes.delete_hk_datasource):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_datasourcePtr(hk_datasource):
    def __init__(self, this):
        _swig_setattr(self, hk_datasource, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_datasource, 'thisown', 0)
        _swig_setattr(self, hk_datasource,self.__class__,hk_datasource)
_hk_classes.hk_datasource_swigregister(hk_datasourcePtr)

class hk_column(hk_class):
    __swig_setmethods__ = {}
    for _s in [hk_class]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_column, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_class]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_column, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C hk_column instance at %s>" % (self.this,)
    def name(*args): return _hk_classes.hk_column_name(*args)
    def set_name(*args): return _hk_classes.hk_column_set_name(*args)
    def is_readonly(*args): return _hk_classes.hk_column_is_readonly(*args)
    def set_readonly(*args): return _hk_classes.hk_column_set_readonly(*args)
    textcolumn = _hk_classes.hk_column_textcolumn
    auto_inccolumn = _hk_classes.hk_column_auto_inccolumn
    smallintegercolumn = _hk_classes.hk_column_smallintegercolumn
    integercolumn = _hk_classes.hk_column_integercolumn
    smallfloatingcolumn = _hk_classes.hk_column_smallfloatingcolumn
    floatingcolumn = _hk_classes.hk_column_floatingcolumn
    datecolumn = _hk_classes.hk_column_datecolumn
    datetimecolumn = _hk_classes.hk_column_datetimecolumn
    timecolumn = _hk_classes.hk_column_timecolumn
    timestampcolumn = _hk_classes.hk_column_timestampcolumn
    binarycolumn = _hk_classes.hk_column_binarycolumn
    memocolumn = _hk_classes.hk_column_memocolumn
    boolcolumn = _hk_classes.hk_column_boolcolumn
    othercolumn = _hk_classes.hk_column_othercolumn
    def columntype(*args): return _hk_classes.hk_column_columntype(*args)
    def set_columntype(*args): return _hk_classes.hk_column_set_columntype(*args)
    def size(*args): return _hk_classes.hk_column_size(*args)
    def set_size(*args): return _hk_classes.hk_column_set_size(*args)
    def columntype_name(*args): return _hk_classes.hk_column_columntype_name(*args)
    def is_primary(*args): return _hk_classes.hk_column_is_primary(*args)
    def set_primary(*args): return _hk_classes.hk_column_set_primary(*args)
    def is_notnull(*args): return _hk_classes.hk_column_is_notnull(*args)
    def set_notnull(*args): return _hk_classes.hk_column_set_notnull(*args)
    def asstring(*args): return _hk_classes.hk_column_asstring(*args)
    def asstring_at(*args): return _hk_classes.hk_column_asstring_at(*args)
    def set_asstring(*args): return _hk_classes.hk_column_set_asstring(*args)
    def changed_data_asstring(*args): return _hk_classes.hk_column_changed_data_asstring(*args)
    def set_asinteger(*args): return _hk_classes.hk_column_set_asinteger(*args)
    def asinteger(*args): return _hk_classes.hk_column_asinteger(*args)
    def asinteger_at(*args): return _hk_classes.hk_column_asinteger_at(*args)
    def changed_data_asinteger(*args): return _hk_classes.hk_column_changed_data_asinteger(*args)
    def set_asdouble(*args): return _hk_classes.hk_column_set_asdouble(*args)
    def asdouble(*args): return _hk_classes.hk_column_asdouble(*args)
    def asdouble_at(*args): return _hk_classes.hk_column_asdouble_at(*args)
    def changed_data_asdouble(*args): return _hk_classes.hk_column_changed_data_asdouble(*args)
    def has_changed(*args): return _hk_classes.hk_column_has_changed(*args)
    def find(*args): return _hk_classes.hk_column_find(*args)
    def set_allow_autoincwrite(*args): return _hk_classes.hk_column_set_allow_autoincwrite(*args)
    def allow_autoincwrite(*args): return _hk_classes.hk_column_allow_autoincwrite(*args)
    def datasource(*args): return _hk_classes.hk_column_datasource(*args)
    def curval_asstring(*args): return _hk_classes.hk_column_curval_asstring(*args)
    def curval_asdouble(*args): return _hk_classes.hk_column_curval_asdouble(*args)
    def curval_asinteger(*args): return _hk_classes.hk_column_curval_asinteger(*args)

class hk_columnPtr(hk_column):
    def __init__(self, this):
        _swig_setattr(self, hk_column, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_column, 'thisown', 0)
        _swig_setattr(self, hk_column,self.__class__,hk_column)
_hk_classes.hk_column_swigregister(hk_columnPtr)

class hk_visible(hk_class):
    __swig_setmethods__ = {}
    for _s in [hk_class]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_visible, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_class]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_visible, name)
    def __repr__(self):
        return "<C hk_visible instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_visible, 'this', _hk_classes.new_hk_visible(*args))
        _swig_setattr(self, hk_visible, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_visible):
        try:
            if self.thisown: destroy(self)
        except: pass
    def set_x(*args): return _hk_classes.hk_visible_set_x(*args)
    def set_y(*args): return _hk_classes.hk_visible_set_y(*args)
    def set_width(*args): return _hk_classes.hk_visible_set_width(*args)
    def set_height(*args): return _hk_classes.hk_visible_set_height(*args)
    def x(*args): return _hk_classes.hk_visible_x(*args)
    def y(*args): return _hk_classes.hk_visible_y(*args)
    def width(*args): return _hk_classes.hk_visible_width(*args)
    def height(*args): return _hk_classes.hk_visible_height(*args)
    def set_size(*args): return _hk_classes.hk_visible_set_size(*args)
    def set_position(*args): return _hk_classes.hk_visible_set_position(*args)
    def set_label(*args): return _hk_classes.hk_visible_set_label(*args)
    def label(*args): return _hk_classes.hk_visible_label(*args)
    def identifier(*args): return _hk_classes.hk_visible_identifier(*args)
    textlabel = _hk_classes.hk_visible_textlabel
    button = _hk_classes.hk_visible_button
    rowselector = _hk_classes.hk_visible_rowselector
    boolean = _hk_classes.hk_visible_boolean
    lineedit = _hk_classes.hk_visible_lineedit
    memo = _hk_classes.hk_visible_memo
    combobox = _hk_classes.hk_visible_combobox
    grid = _hk_classes.hk_visible_grid
    form = _hk_classes.hk_visible_form
    report = _hk_classes.hk_visible_report
    reportsection = _hk_classes.hk_visible_reportsection
    reportdata = _hk_classes.hk_visible_reportdata
    query = _hk_classes.hk_visible_query
    subform = _hk_classes.hk_visible_subform
    other = _hk_classes.hk_visible_other
    def type(*args): return _hk_classes.hk_visible_type(*args)
    def set_font(*args): return _hk_classes.hk_visible_set_font(*args)
    def font(*args): return _hk_classes.hk_visible_font(*args)
    def set_foregroundcolour(*args): return _hk_classes.hk_visible_set_foregroundcolour(*args)
    def foregroundcolour(*args): return _hk_classes.hk_visible_foregroundcolour(*args)
    def set_backgroundcolour(*args): return _hk_classes.hk_visible_set_backgroundcolour(*args)
    def backgroundcolour(*args): return _hk_classes.hk_visible_backgroundcolour(*args)
    def presentation(*args): return _hk_classes.hk_visible_presentation(*args)

class hk_visiblePtr(hk_visible):
    def __init__(self, this):
        _swig_setattr(self, hk_visible, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_visible, 'thisown', 0)
        _swig_setattr(self, hk_visible,self.__class__,hk_visible)
_hk_classes.hk_visible_swigregister(hk_visiblePtr)


currentvisible = _hk_classes.currentvisible

cast_button = _hk_classes.cast_button

cast_dslineedit = _hk_classes.cast_dslineedit

cast_dsmemo = _hk_classes.cast_dsmemo

cast_dsgrid = _hk_classes.cast_dsgrid

cast_dscombobox = _hk_classes.cast_dscombobox

cast_dsboolean = _hk_classes.cast_dsboolean

cast_dsvisible = _hk_classes.cast_dsvisible

cast_subform = _hk_classes.cast_subform

cast_form = _hk_classes.cast_form

cast_report = _hk_classes.cast_report
class hk_dsvisible(hk_visible):
    __swig_setmethods__ = {}
    for _s in [hk_visible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_dsvisible, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_visible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_dsvisible, name)
    def __repr__(self):
        return "<C hk_dsvisible instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_dsvisible, 'this', _hk_classes.new_hk_dsvisible(*args))
        _swig_setattr(self, hk_dsvisible, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_dsvisible):
        try:
            if self.thisown: destroy(self)
        except: pass
    def set_datasource(*args): return _hk_classes.hk_dsvisible_set_datasource(*args)
    def set_presentationdatasource(*args): return _hk_classes.hk_dsvisible_set_presentationdatasource(*args)
    def presentationdatasource(*args): return _hk_classes.hk_dsvisible_presentationdatasource(*args)
    def datasource(*args): return _hk_classes.hk_dsvisible_datasource(*args)

class hk_dsvisiblePtr(hk_dsvisible):
    def __init__(self, this):
        _swig_setattr(self, hk_dsvisible, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_dsvisible, 'thisown', 0)
        _swig_setattr(self, hk_dsvisible,self.__class__,hk_dsvisible)
_hk_classes.hk_dsvisible_swigregister(hk_dsvisiblePtr)


currentdsvisible = _hk_classes.currentdsvisible

currentgrid = _hk_classes.currentgrid
class hk_dsdatavisible(hk_dsvisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsvisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_dsdatavisible, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsvisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_dsdatavisible, name)
    def __repr__(self):
        return "<C hk_dsdatavisible instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_dsdatavisible, 'this', _hk_classes.new_hk_dsdatavisible(*args))
        _swig_setattr(self, hk_dsdatavisible, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_dsdatavisible):
        try:
            if self.thisown: destroy(self)
        except: pass
    def set_columnname(*args): return _hk_classes.hk_dsdatavisible_set_columnname(*args)
    def column(*args): return _hk_classes.hk_dsdatavisible_column(*args)
    def columnname(*args): return _hk_classes.hk_dsdatavisible_columnname(*args)
    def use_defaultvalue(*args): return _hk_classes.hk_dsdatavisible_use_defaultvalue(*args)
    def set_defaultvalue(*args): return _hk_classes.hk_dsdatavisible_set_defaultvalue(*args)
    def raw_defaultvalue(*args): return _hk_classes.hk_dsdatavisible_raw_defaultvalue(*args)
    def defaultvalue(*args): return _hk_classes.hk_dsdatavisible_defaultvalue(*args)
    def reset_default(*args): return _hk_classes.hk_dsdatavisible_reset_default(*args)
    def set_numberformat(*args): return _hk_classes.hk_dsdatavisible_set_numberformat(*args)
    def use_numberseparator(*args): return _hk_classes.hk_dsdatavisible_use_numberseparator(*args)
    def precision(*args): return _hk_classes.hk_dsdatavisible_precision(*args)
    __swig_getmethods__["set_defaultnumberformat"] = lambda x: _hk_classes.hk_dsdatavisible_set_defaultnumberformat
    if _newclass:set_defaultnumberformat = staticmethod(_hk_classes.hk_dsdatavisible_set_defaultnumberformat)
    __swig_getmethods__["defaultuse_numberseparator"] = lambda x: _hk_classes.hk_dsdatavisible_defaultuse_numberseparator
    if _newclass:defaultuse_numberseparator = staticmethod(_hk_classes.hk_dsdatavisible_defaultuse_numberseparator)
    __swig_getmethods__["defaultprecision"] = lambda x: _hk_classes.hk_dsdatavisible_defaultprecision
    if _newclass:defaultprecision = staticmethod(_hk_classes.hk_dsdatavisible_defaultprecision)
    def value_at(*args): return _hk_classes.hk_dsdatavisible_value_at(*args)
    def value(*args): return _hk_classes.hk_dsdatavisible_value(*args)
    def set_value(*args): return _hk_classes.hk_dsdatavisible_set_value(*args)
    def find(*args): return _hk_classes.hk_dsdatavisible_find(*args)

class hk_dsdatavisiblePtr(hk_dsdatavisible):
    def __init__(self, this):
        _swig_setattr(self, hk_dsdatavisible, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_dsdatavisible, 'thisown', 0)
        _swig_setattr(self, hk_dsdatavisible,self.__class__,hk_dsdatavisible)
_hk_classes.hk_dsdatavisible_swigregister(hk_dsdatavisiblePtr)

hk_dsdatavisible_set_defaultnumberformat = _hk_classes.hk_dsdatavisible_set_defaultnumberformat

hk_dsdatavisible_defaultuse_numberseparator = _hk_classes.hk_dsdatavisible_defaultuse_numberseparator

hk_dsdatavisible_defaultprecision = _hk_classes.hk_dsdatavisible_defaultprecision

class hk_dslineedit(hk_dsdatavisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_dslineedit, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_dslineedit, name)
    def __repr__(self):
        return "<C hk_dslineedit instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_dslineedit, 'this', _hk_classes.new_hk_dslineedit(*args))
        _swig_setattr(self, hk_dslineedit, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_dslineedit):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_dslineeditPtr(hk_dslineedit):
    def __init__(self, this):
        _swig_setattr(self, hk_dslineedit, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_dslineedit, 'thisown', 0)
        _swig_setattr(self, hk_dslineedit,self.__class__,hk_dslineedit)
_hk_classes.hk_dslineedit_swigregister(hk_dslineeditPtr)

class hk_dsmemo(hk_dsdatavisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_dsmemo, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_dsmemo, name)
    def __repr__(self):
        return "<C hk_dsmemo instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_dsmemo, 'this', _hk_classes.new_hk_dsmemo(*args))
        _swig_setattr(self, hk_dsmemo, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_dsmemo):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_dsmemoPtr(hk_dsmemo):
    def __init__(self, this):
        _swig_setattr(self, hk_dsmemo, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_dsmemo, 'thisown', 0)
        _swig_setattr(self, hk_dsmemo,self.__class__,hk_dsmemo)
_hk_classes.hk_dsmemo_swigregister(hk_dsmemoPtr)

class hk_dsboolean(hk_dsdatavisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_dsboolean, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_dsboolean, name)
    def __repr__(self):
        return "<C hk_dsboolean instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_dsboolean, 'this', _hk_classes.new_hk_dsboolean(*args))
        _swig_setattr(self, hk_dsboolean, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_dsboolean):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_dsbooleanPtr(hk_dsboolean):
    def __init__(self, this):
        _swig_setattr(self, hk_dsboolean, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_dsboolean, 'thisown', 0)
        _swig_setattr(self, hk_dsboolean,self.__class__,hk_dsboolean)
_hk_classes.hk_dsboolean_swigregister(hk_dsbooleanPtr)


currentlineedit = _hk_classes.currentlineedit

currentboolean = _hk_classes.currentboolean

currentcombobox = _hk_classes.currentcombobox

currentmemo = _hk_classes.currentmemo
class hk_font(hk_class):
    __swig_setmethods__ = {}
    for _s in [hk_class]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_font, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_class]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_font, name)
    def __repr__(self):
        return "<C hk_font instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_font, 'this', _hk_classes.new_hk_font(*args))
        _swig_setattr(self, hk_font, 'thisown', 1)
    def set_font(*args): return _hk_classes.hk_font_set_font(*args)
    def fontname(*args): return _hk_classes.hk_font_fontname(*args)
    def fontsize(*args): return _hk_classes.hk_font_fontsize(*args)
    def set_bold(*args): return _hk_classes.hk_font_set_bold(*args)
    def bold(*args): return _hk_classes.hk_font_bold(*args)
    def set_italic(*args): return _hk_classes.hk_font_set_italic(*args)
    def italic(*args): return _hk_classes.hk_font_italic(*args)
    def __del__(self, destroy=_hk_classes.delete_hk_font):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_fontPtr(hk_font):
    def __init__(self, this):
        _swig_setattr(self, hk_font, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_font, 'thisown', 0)
        _swig_setattr(self, hk_font,self.__class__,hk_font)
_hk_classes.hk_font_swigregister(hk_fontPtr)

class hk_colour(hk_class):
    __swig_setmethods__ = {}
    for _s in [hk_class]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_colour, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_class]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_colour, name)
    def __repr__(self):
        return "<C hk_colour instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_colour, 'this', _hk_classes.new_hk_colour(*args))
        _swig_setattr(self, hk_colour, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_colour):
        try:
            if self.thisown: destroy(self)
        except: pass
    def set_colour(*args): return _hk_classes.hk_colour_set_colour(*args)
    def red(*args): return _hk_classes.hk_colour_red(*args)
    def green(*args): return _hk_classes.hk_colour_green(*args)
    def blue(*args): return _hk_classes.hk_colour_blue(*args)

class hk_colourPtr(hk_colour):
    def __init__(self, this):
        _swig_setattr(self, hk_colour, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_colour, 'thisown', 0)
        _swig_setattr(self, hk_colour,self.__class__,hk_colour)
_hk_classes.hk_colour_swigregister(hk_colourPtr)

class hk_dsmodevisible(hk_dsvisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsvisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_dsmodevisible, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsvisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_dsmodevisible, name)
    def __repr__(self):
        return "<C hk_dsmodevisible instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_dsmodevisible, 'this', _hk_classes.new_hk_dsmodevisible(*args))
        _swig_setattr(self, hk_dsmodevisible, 'thisown', 1)
    designmode = _hk_classes.hk_dsmodevisible_designmode
    viewmode = _hk_classes.hk_dsmodevisible_viewmode
    def mode(*args): return _hk_classes.hk_dsmodevisible_mode(*args)
    def set_mode(*args): return _hk_classes.hk_dsmodevisible_set_mode(*args)
    def has_changed(*args): return _hk_classes.hk_dsmodevisible_has_changed(*args)
    def set_block_has_changed(*args): return _hk_classes.hk_dsmodevisible_set_block_has_changed(*args)
    def block_has_changed(*args): return _hk_classes.hk_dsmodevisible_block_has_changed(*args)
    def reset_has_changed(*args): return _hk_classes.hk_dsmodevisible_reset_has_changed(*args)
    def __del__(self, destroy=_hk_classes.delete_hk_dsmodevisible):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_dsmodevisiblePtr(hk_dsmodevisible):
    def __init__(self, this):
        _swig_setattr(self, hk_dsmodevisible, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_dsmodevisible, 'thisown', 0)
        _swig_setattr(self, hk_dsmodevisible,self.__class__,hk_dsmodevisible)
_hk_classes.hk_dsmodevisible_swigregister(hk_dsmodevisiblePtr)
cvar = _hk_classes.cvar
hk_aqua = cvar.hk_aqua
hk_beige = cvar.hk_beige
hk_black = cvar.hk_black
hk_blue = cvar.hk_blue
hk_brown = cvar.hk_brown
hk_fuchsia = cvar.hk_fuchsia
hk_darkgrey = cvar.hk_darkgrey
hk_green = cvar.hk_green
hk_grey = cvar.hk_grey
hk_lightgrey = cvar.hk_lightgrey
hk_lime = cvar.hk_lime
hk_maroon = cvar.hk_maroon
hk_navy = cvar.hk_navy
hk_olive = cvar.hk_olive
hk_orange = cvar.hk_orange
hk_pink = cvar.hk_pink
hk_purple = cvar.hk_purple
hk_red = cvar.hk_red
hk_silver = cvar.hk_silver
hk_teal = cvar.hk_teal
hk_white = cvar.hk_white
hk_yellow = cvar.hk_yellow

class hk_dstable(hk_dsmodevisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsmodevisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_dstable, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsmodevisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_dstable, name)
    def __repr__(self):
        return "<C hk_dstable instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_dstable, 'this', _hk_classes.new_hk_dstable(*args))
        _swig_setattr(self, hk_dstable, 'thisown', 1)
    def grid(*args): return _hk_classes.hk_dstable_grid(*args)
    def __del__(self, destroy=_hk_classes.delete_hk_dstable):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_dstablePtr(hk_dstable):
    def __init__(self, this):
        _swig_setattr(self, hk_dstable, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_dstable, 'thisown', 0)
        _swig_setattr(self, hk_dstable,self.__class__,hk_dstable)
_hk_classes.hk_dstable_swigregister(hk_dstablePtr)

class hk_dsquery(hk_dsmodevisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsmodevisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_dsquery, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsmodevisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_dsquery, name)
    def __repr__(self):
        return "<C hk_dsquery instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_dsquery, 'this', _hk_classes.new_hk_dsquery(*args))
        _swig_setattr(self, hk_dsquery, 'thisown', 1)
    def grid(*args): return _hk_classes.hk_dsquery_grid(*args)
    def save_query(*args): return _hk_classes.hk_dsquery_save_query(*args)
    def load_query(*args): return _hk_classes.hk_dsquery_load_query(*args)
    def __del__(self, destroy=_hk_classes.delete_hk_dsquery):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_dsqueryPtr(hk_dsquery):
    def __init__(self, this):
        _swig_setattr(self, hk_dsquery, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_dsquery, 'thisown', 0)
        _swig_setattr(self, hk_dsquery,self.__class__,hk_dsquery)
_hk_classes.hk_dsquery_swigregister(hk_dsqueryPtr)

class hk_presentation(hk_dsmodevisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsmodevisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_presentation, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsmodevisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_presentation, name)
    def __repr__(self):
        return "<C hk_presentation instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_presentation, 'this', _hk_classes.new_hk_presentation(*args))
        _swig_setattr(self, hk_presentation, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_presentation):
        try:
            if self.thisown: destroy(self)
        except: pass
    def set_database(*args): return _hk_classes.hk_presentation_set_database(*args)
    def database(*args): return _hk_classes.hk_presentation_database(*args)
    general = _hk_classes.hk_presentation_general
    form = _hk_classes.hk_presentation_form
    report = _hk_classes.hk_presentation_report
    def presentationtype(*args): return _hk_classes.hk_presentation_presentationtype(*args)
    def set_name(*args): return _hk_classes.hk_presentation_set_name(*args)
    def name(*args): return _hk_classes.hk_presentation_name(*args)
    def datasources(*args): return _hk_classes.hk_presentation_datasources(*args)
    def new_datasource(*args): return _hk_classes.hk_presentation_new_datasource(*args)
    def get_datasource(*args): return _hk_classes.hk_presentation_get_datasource(*args)
    def unique_datasourcename(*args): return _hk_classes.hk_presentation_unique_datasourcename(*args)
    def clear_datasourcelist(*args): return _hk_classes.hk_presentation_clear_datasourcelist(*args)
    def has_changed(*args): return _hk_classes.hk_presentation_has_changed(*args)
    def set_designsize(*args): return _hk_classes.hk_presentation_set_designsize(*args)
    def set_presentationsize(*args): return _hk_classes.hk_presentation_set_presentationsize(*args)
    def designwidth(*args): return _hk_classes.hk_presentation_designwidth(*args)
    def designheight(*args): return _hk_classes.hk_presentation_designheight(*args)
    def horizontal2relativ(*args): return _hk_classes.hk_presentation_horizontal2relativ(*args)
    def vertical2relativ(*args): return _hk_classes.hk_presentation_vertical2relativ(*args)
    def relativ2horizontal(*args): return _hk_classes.hk_presentation_relativ2horizontal(*args)
    def relativ2vertical(*args): return _hk_classes.hk_presentation_relativ2vertical(*args)
    def set_automatic_enable_datasources(*args): return _hk_classes.hk_presentation_set_automatic_enable_datasources(*args)
    def automatic_enable_datasources(*args): return _hk_classes.hk_presentation_automatic_enable_datasources(*args)
    bulkfont = _hk_classes.hk_presentation_bulkfont
    bulkforeground = _hk_classes.hk_presentation_bulkforeground
    bulkbackground = _hk_classes.hk_presentation_bulkbackground
    def bulk_operation(*args): return _hk_classes.hk_presentation_bulk_operation(*args)
    relative = _hk_classes.hk_presentation_relative
    absolute = _hk_classes.hk_presentation_absolute
    def set_sizetype(*args): return _hk_classes.hk_presentation_set_sizetype(*args)
    def sizetype(*args): return _hk_classes.hk_presentation_sizetype(*args)
    def enable_datasources(*args): return _hk_classes.hk_presentation_enable_datasources(*args)

class hk_presentationPtr(hk_presentation):
    def __init__(self, this):
        _swig_setattr(self, hk_presentation, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_presentation, 'thisown', 0)
        _swig_setattr(self, hk_presentation,self.__class__,hk_presentation)
_hk_classes.hk_presentation_swigregister(hk_presentationPtr)

class hk_button(hk_dsvisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsvisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_button, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsvisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_button, name)
    def __repr__(self):
        return "<C hk_button instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_button, 'this', _hk_classes.new_hk_button(*args))
        _swig_setattr(self, hk_button, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_button):
        try:
            if self.thisown: destroy(self)
        except: pass
    def set_action(*args): return _hk_classes.hk_button_set_action(*args)
    def push_action(*args): return _hk_classes.hk_button_push_action(*args)
    def object(*args): return _hk_classes.hk_button_object(*args)
    def action(*args): return _hk_classes.hk_button_action(*args)
    def show_maximized(*args): return _hk_classes.hk_button_show_maximized(*args)
    def set_database(*args): return _hk_classes.hk_button_set_database(*args)
    def database(*args): return _hk_classes.hk_button_database(*args)

class hk_buttonPtr(hk_button):
    def __init__(self, this):
        _swig_setattr(self, hk_button, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_button, 'thisown', 0)
        _swig_setattr(self, hk_button,self.__class__,hk_button)
_hk_classes.hk_button_swigregister(hk_buttonPtr)


currentbutton = _hk_classes.currentbutton
class hk_form(hk_presentation):
    __swig_setmethods__ = {}
    for _s in [hk_presentation]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_form, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_presentation]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_form, name)
    def __repr__(self):
        return "<C hk_form instance at %s>" % (self.this,)
    def load_form(*args): return _hk_classes.hk_form_load_form(*args)
    def save_form(*args): return _hk_classes.hk_form_save_form(*args)
    def new_grid(*args): return _hk_classes.hk_form_new_grid(*args)
    def new_lineedit(*args): return _hk_classes.hk_form_new_lineedit(*args)
    def new_bool(*args): return _hk_classes.hk_form_new_bool(*args)
    def new_combobox(*args): return _hk_classes.hk_form_new_combobox(*args)
    def new_button(*args): return _hk_classes.hk_form_new_button(*args)
    def new_rowselector(*args): return _hk_classes.hk_form_new_rowselector(*args)
    def new_memo(*args): return _hk_classes.hk_form_new_memo(*args)
    def new_label(*args): return _hk_classes.hk_form_new_label(*args)
    def new_subform(*args): return _hk_classes.hk_form_new_subform(*args)
    def set_designsize(*args): return _hk_classes.hk_form_set_designsize(*args)
    def get_visible(*args): return _hk_classes.hk_form_get_visible(*args)
    def bulk_operation(*args): return _hk_classes.hk_form_bulk_operation(*args)
    def set_mode(*args): return _hk_classes.hk_form_set_mode(*args)
    def clear_visiblelist(*args): return _hk_classes.hk_form_clear_visiblelist(*args)
    def __init__(self, *args):
        _swig_setattr(self, hk_form, 'this', _hk_classes.new_hk_form(*args))
        _swig_setattr(self, hk_form, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_form):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_formPtr(hk_form):
    def __init__(self, this):
        _swig_setattr(self, hk_form, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_form, 'thisown', 0)
        _swig_setattr(self, hk_form,self.__class__,hk_form)
_hk_classes.hk_form_swigregister(hk_formPtr)


currentform = _hk_classes.currentform
class hk_label(hk_visible):
    __swig_setmethods__ = {}
    for _s in [hk_visible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_label, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_visible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_label, name)
    def __repr__(self):
        return "<C hk_label instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_label, 'this', _hk_classes.new_hk_label(*args))
        _swig_setattr(self, hk_label, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_label):
        try:
            if self.thisown: destroy(self)
        except: pass
    def set_topline(*args): return _hk_classes.hk_label_set_topline(*args)
    def set_bottomline(*args): return _hk_classes.hk_label_set_bottomline(*args)
    def set_leftline(*args): return _hk_classes.hk_label_set_leftline(*args)
    def set_rightline(*args): return _hk_classes.hk_label_set_rightline(*args)
    def set_diagonalluro(*args): return _hk_classes.hk_label_set_diagonalluro(*args)
    def set_diagonalloru(*args): return _hk_classes.hk_label_set_diagonalloru(*args)
    def diagonalloru(*args): return _hk_classes.hk_label_diagonalloru(*args)
    def topline(*args): return _hk_classes.hk_label_topline(*args)
    def bottomline(*args): return _hk_classes.hk_label_bottomline(*args)
    def leftline(*args): return _hk_classes.hk_label_leftline(*args)
    def rightline(*args): return _hk_classes.hk_label_rightline(*args)
    def diagonalluro(*args): return _hk_classes.hk_label_diagonalluro(*args)
    def set_frame(*args): return _hk_classes.hk_label_set_frame(*args)

class hk_labelPtr(hk_label):
    def __init__(self, this):
        _swig_setattr(self, hk_label, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_label, 'thisown', 0)
        _swig_setattr(self, hk_label,self.__class__,hk_label)
_hk_classes.hk_label_swigregister(hk_labelPtr)

class hk_report(hk_presentation):
    __swig_setmethods__ = {}
    for _s in [hk_presentation]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_report, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_presentation]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_report, name)
    def __repr__(self):
        return "<C hk_report instance at %s>" % (self.this,)
    def load_report(*args): return _hk_classes.hk_report_load_report(*args)
    def save_report(*args): return _hk_classes.hk_report_save_report(*args)
    def get_reportdatavisible(*args): return _hk_classes.hk_report_get_reportdatavisible(*args)
    def set_begin(*args): return _hk_classes.hk_report_set_begin(*args)
    def begin(*args): return _hk_classes.hk_report_begin(*args)
    def set_end(*args): return _hk_classes.hk_report_set_end(*args)
    def end(*args): return _hk_classes.hk_report_end(*args)
    def page_header(*args): return _hk_classes.hk_report_page_header(*args)
    def page_footer(*args): return _hk_classes.hk_report_page_footer(*args)
    def report_header(*args): return _hk_classes.hk_report_report_header(*args)
    def report_footer(*args): return _hk_classes.hk_report_report_footer(*args)
    def set_filename(*args): return _hk_classes.hk_report_set_filename(*args)
    def filename(*args): return _hk_classes.hk_report_filename(*args)
    def set_fileextension(*args): return _hk_classes.hk_report_set_fileextension(*args)
    def fileextension(*args): return _hk_classes.hk_report_fileextension(*args)
    def set_firstpagenumber(*args): return _hk_classes.hk_report_set_firstpagenumber(*args)
    def firstpagenumber(*args): return _hk_classes.hk_report_firstpagenumber(*args)
    def datasection(*args): return _hk_classes.hk_report_datasection(*args)
    def new_sectionpair(*args): return _hk_classes.hk_report_new_sectionpair(*args)
    def new_sectionpair_at(*args): return _hk_classes.hk_report_new_sectionpair_at(*args)
    def move_sectionpair(*args): return _hk_classes.hk_report_move_sectionpair(*args)
    def set_reporttype(*args): return _hk_classes.hk_report_set_reporttype(*args)
    def reporttype(*args): return _hk_classes.hk_report_reporttype(*args)
    __swig_getmethods__["reporttypelist"] = lambda x: _hk_classes.hk_report_reporttypelist
    if _newclass:reporttypelist = staticmethod(_hk_classes.hk_report_reporttypelist)
    def default_reportdata(*args): return _hk_classes.hk_report_default_reportdata(*args)
    def set_default_reportdata(*args): return _hk_classes.hk_report_set_default_reportdata(*args)
    def default_beforereportdata(*args): return _hk_classes.hk_report_default_beforereportdata(*args)
    def set_default_beforereportdata(*args): return _hk_classes.hk_report_set_default_beforereportdata(*args)
    def default_afterreportdata(*args): return _hk_classes.hk_report_default_afterreportdata(*args)
    def set_default_afterreportdata(*args): return _hk_classes.hk_report_set_default_afterreportdata(*args)
    def default_reportprecision(*args): return _hk_classes.hk_report_default_reportprecision(*args)
    def set_default_reportprecision(*args): return _hk_classes.hk_report_set_default_reportprecision(*args)
    def default_use_reportseparator(*args): return _hk_classes.hk_report_default_use_reportseparator(*args)
    def set_default_use_reportseparator(*args): return _hk_classes.hk_report_set_default_use_reportseparator(*args)
    def set_default_reportdataconfigurefunction(*args): return _hk_classes.hk_report_set_default_reportdataconfigurefunction(*args)
    def default_reportdataconfigurefunction(*args): return _hk_classes.hk_report_default_reportdataconfigurefunction(*args)
    def set_default_reportsectionbegin(*args): return _hk_classes.hk_report_set_default_reportsectionbegin(*args)
    def default_reportsectionbegin(*args): return _hk_classes.hk_report_default_reportsectionbegin(*args)
    def set_default_reportsectionend(*args): return _hk_classes.hk_report_set_default_reportsectionend(*args)
    def default_reportsectionend(*args): return _hk_classes.hk_report_default_reportsectionend(*args)
    def set_default_reportsectionbetweendata(*args): return _hk_classes.hk_report_set_default_reportsectionbetweendata(*args)
    def default_reportsectionbetweendata(*args): return _hk_classes.hk_report_default_reportsectionbetweendata(*args)
    def set_default_reportsectioncountfunction(*args): return _hk_classes.hk_report_set_default_reportsectioncountfunction(*args)
    def default_reportsectioncountfunction(*args): return _hk_classes.hk_report_default_reportsectioncountfunction(*args)
    def set_topline(*args): return _hk_classes.hk_report_set_topline(*args)
    def topline(*args): return _hk_classes.hk_report_topline(*args)
    def set_bottomline(*args): return _hk_classes.hk_report_set_bottomline(*args)
    def bottomline(*args): return _hk_classes.hk_report_bottomline(*args)
    def set_leftline(*args): return _hk_classes.hk_report_set_leftline(*args)
    def leftline(*args): return _hk_classes.hk_report_leftline(*args)
    def set_rightline(*args): return _hk_classes.hk_report_set_rightline(*args)
    def rightline(*args): return _hk_classes.hk_report_rightline(*args)
    def set_diagonalluro(*args): return _hk_classes.hk_report_set_diagonalluro(*args)
    def diagonalluro(*args): return _hk_classes.hk_report_diagonalluro(*args)
    def set_diagonalloru(*args): return _hk_classes.hk_report_set_diagonalloru(*args)
    def diagonalloru(*args): return _hk_classes.hk_report_diagonalloru(*args)
    def set_frame(*args): return _hk_classes.hk_report_set_frame(*args)
    def set_borders(*args): return _hk_classes.hk_report_set_borders(*args)
    def border_left(*args): return _hk_classes.hk_report_border_left(*args)
    def border_right(*args): return _hk_classes.hk_report_border_right(*args)
    def border_top(*args): return _hk_classes.hk_report_border_top(*args)
    def border_bottom(*args): return _hk_classes.hk_report_border_bottom(*args)
    landscape = _hk_classes.hk_report_landscape
    portrait = _hk_classes.hk_report_portrait
    def set_orientation(*args): return _hk_classes.hk_report_set_orientation(*args)
    def orientation(*args): return _hk_classes.hk_report_orientation(*args)
    A0 = _hk_classes.hk_report_A0
    A1 = _hk_classes.hk_report_A1
    A2 = _hk_classes.hk_report_A2
    A3 = _hk_classes.hk_report_A3
    A4 = _hk_classes.hk_report_A4
    A5 = _hk_classes.hk_report_A5
    A6 = _hk_classes.hk_report_A6
    A7 = _hk_classes.hk_report_A7
    A8 = _hk_classes.hk_report_A8
    A9 = _hk_classes.hk_report_A9
    A10 = _hk_classes.hk_report_A10
    letter = _hk_classes.hk_report_letter
    legal = _hk_classes.hk_report_legal
    executive = _hk_classes.hk_report_executive
    tabloid = _hk_classes.hk_report_tabloid
    userdefined = _hk_classes.hk_report_userdefined
    def set_pageformat(*args): return _hk_classes.hk_report_set_pageformat(*args)
    def pageformat(*args): return _hk_classes.hk_report_pageformat(*args)
    def formatwidth(*args): return _hk_classes.hk_report_formatwidth(*args)
    def formatheight(*args): return _hk_classes.hk_report_formatheight(*args)
    def set_reportconfigurefunction(*args): return _hk_classes.hk_report_set_reportconfigurefunction(*args)
    def __init__(self, *args):
        _swig_setattr(self, hk_report, 'this', _hk_classes.new_hk_report(*args))
        _swig_setattr(self, hk_report, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_report):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_reportPtr(hk_report):
    def __init__(self, this):
        _swig_setattr(self, hk_report, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_report, 'thisown', 0)
        _swig_setattr(self, hk_report,self.__class__,hk_report)
_hk_classes.hk_report_swigregister(hk_reportPtr)

hk_report_reporttypelist = _hk_classes.hk_report_reporttypelist


currentreport = _hk_classes.currentreport
class hk_reportsection(hk_dsdatavisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_reportsection, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_reportsection, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C hk_reportsection instance at %s>" % (self.this,)
    def set_unique(*args): return _hk_classes.hk_reportsection_set_unique(*args)
    def unique(*args): return _hk_classes.hk_reportsection_unique(*args)
    def new_data(*args): return _hk_classes.hk_reportsection_new_data(*args)
    def data_at(*args): return _hk_classes.hk_reportsection_data_at(*args)
    def datalist(*args): return _hk_classes.hk_reportsection_datalist(*args)
    def actual_string(*args): return _hk_classes.hk_reportsection_actual_string(*args)
    def sectionbegin(*args): return _hk_classes.hk_reportsection_sectionbegin(*args)
    def set_sectionbegin(*args): return _hk_classes.hk_reportsection_set_sectionbegin(*args)
    def sectionend(*args): return _hk_classes.hk_reportsection_sectionend(*args)
    def set_sectionend(*args): return _hk_classes.hk_reportsection_set_sectionend(*args)
    def betweendata(*args): return _hk_classes.hk_reportsection_betweendata(*args)
    def set_betweendata(*args): return _hk_classes.hk_reportsection_set_betweendata(*args)
    def new_uniquevalue(*args): return _hk_classes.hk_reportsection_new_uniquevalue(*args)
    def endsection(*args): return _hk_classes.hk_reportsection_endsection(*args)
    def set_automatic_create_data(*args): return _hk_classes.hk_reportsection_set_automatic_create_data(*args)
    def new_page_after_section(*args): return _hk_classes.hk_reportsection_new_page_after_section(*args)
    def set_new_page_after_section(*args): return _hk_classes.hk_reportsection_set_new_page_after_section(*args)
    def section_was_printed(*args): return _hk_classes.hk_reportsection_section_was_printed(*args)
    def set_subreport(*args): return _hk_classes.hk_reportsection_set_subreport(*args)
    def subreportname(*args): return _hk_classes.hk_reportsection_subreportname(*args)
    def subreport(*args): return _hk_classes.hk_reportsection_subreport(*args)
    def add_depending_fields(*args): return _hk_classes.hk_reportsection_add_depending_fields(*args)
    def clear_depending_fields(*args): return _hk_classes.hk_reportsection_clear_depending_fields(*args)
    def depending_on_thisreportfields(*args): return _hk_classes.hk_reportsection_depending_on_thisreportfields(*args)
    def depending_on_subreportfields(*args): return _hk_classes.hk_reportsection_depending_on_subreportfields(*args)
    def print_subreport_before_data(*args): return _hk_classes.hk_reportsection_print_subreport_before_data(*args)
    def print_subreport(*args): return _hk_classes.hk_reportsection_print_subreport(*args)
    def set_replacefunction(*args): return _hk_classes.hk_reportsection_set_replacefunction(*args)
    def replace(*args): return _hk_classes.hk_reportsection_replace(*args)
    __swig_getmethods__["add_sectionreplacefunctiontype"] = lambda x: _hk_classes.hk_reportsection_add_sectionreplacefunctiontype
    if _newclass:add_sectionreplacefunctiontype = staticmethod(_hk_classes.hk_reportsection_add_sectionreplacefunctiontype)
    __swig_getmethods__["sectionreplacefunctionlist"] = lambda x: _hk_classes.hk_reportsection_sectionreplacefunctionlist
    if _newclass:sectionreplacefunctionlist = staticmethod(_hk_classes.hk_reportsection_sectionreplacefunctionlist)
    def reset_count(*args): return _hk_classes.hk_reportsection_reset_count(*args)
    def font(*args): return _hk_classes.hk_reportsection_font(*args)
    def counts_as(*args): return _hk_classes.hk_reportsection_counts_as(*args)
    __swig_getmethods__["add_sectioncountfunctiontype"] = lambda x: _hk_classes.hk_reportsection_add_sectioncountfunctiontype
    if _newclass:add_sectioncountfunctiontype = staticmethod(_hk_classes.hk_reportsection_add_sectioncountfunctiontype)
    __swig_getmethods__["sectioncountfunctionlist"] = lambda x: _hk_classes.hk_reportsection_sectioncountfunctionlist
    if _newclass:sectioncountfunctionlist = staticmethod(_hk_classes.hk_reportsection_sectioncountfunctionlist)
    def set_sectioncountfunction(*args): return _hk_classes.hk_reportsection_set_sectioncountfunction(*args)
    def sectioncountfunctionstring(*args): return _hk_classes.hk_reportsection_sectioncountfunctionstring(*args)
    def sectioncountfunction(*args): return _hk_classes.hk_reportsection_sectioncountfunction(*args)
    def savedata(*args): return _hk_classes.hk_reportsection_savedata(*args)
    def loaddata(*args): return _hk_classes.hk_reportsection_loaddata(*args)
    def set_datasource(*args): return _hk_classes.hk_reportsection_set_datasource(*args)
    def set_presentationdatasource(*args): return _hk_classes.hk_reportsection_set_presentationdatasource(*args)
    def default_reportdata(*args): return _hk_classes.hk_reportsection_default_reportdata(*args)
    def set_default_reportdata(*args): return _hk_classes.hk_reportsection_set_default_reportdata(*args)
    def default_beforereportdata(*args): return _hk_classes.hk_reportsection_default_beforereportdata(*args)
    def set_default_beforereportdata(*args): return _hk_classes.hk_reportsection_set_default_beforereportdata(*args)
    def default_afterreportdata(*args): return _hk_classes.hk_reportsection_default_afterreportdata(*args)
    def set_default_afterreportdata(*args): return _hk_classes.hk_reportsection_set_default_afterreportdata(*args)
    def set_default_reportdataconfigurefunction(*args): return _hk_classes.hk_reportsection_set_default_reportdataconfigurefunction(*args)
    def default_reportdataconfigurefunction(*args): return _hk_classes.hk_reportsection_default_reportdataconfigurefunction(*args)
    def default_reportprecision(*args): return _hk_classes.hk_reportsection_default_reportprecision(*args)
    def set_default_reportprecision(*args): return _hk_classes.hk_reportsection_set_default_reportprecision(*args)
    def default_use_reportseparator(*args): return _hk_classes.hk_reportsection_default_use_reportseparator(*args)
    def set_default_use_reportseparator(*args): return _hk_classes.hk_reportsection_set_default_use_reportseparator(*args)
    def neutralize_definition(*args): return _hk_classes.hk_reportsection_neutralize_definition(*args)
    def reset(*args): return _hk_classes.hk_reportsection_reset(*args)
    def clear_countingfields(*args): return _hk_classes.hk_reportsection_clear_countingfields(*args)
    def remove_data(*args): return _hk_classes.hk_reportsection_remove_data(*args)
    def report(*args): return _hk_classes.hk_reportsection_report(*args)
    def horizontal2relativ(*args): return _hk_classes.hk_reportsection_horizontal2relativ(*args)
    def vertical2relativ(*args): return _hk_classes.hk_reportsection_vertical2relativ(*args)
    def relativ2horizontal(*args): return _hk_classes.hk_reportsection_relativ2horizontal(*args)
    def relativ2vertical(*args): return _hk_classes.hk_reportsection_relativ2vertical(*args)
    def reportsectionpair(*args): return _hk_classes.hk_reportsection_reportsectionpair(*args)
    def set_offset(*args): return _hk_classes.hk_reportsection_set_offset(*args)
    def offset(*args): return _hk_classes.hk_reportsection_offset(*args)
    def bulk_operation(*args): return _hk_classes.hk_reportsection_bulk_operation(*args)
    def set_automaticcreatedatafunction(*args): return _hk_classes.hk_reportsection_set_automaticcreatedatafunction(*args)
    def automaticcreatedatafunction(*args): return _hk_classes.hk_reportsection_automaticcreatedatafunction(*args)
    def get_reportdatavisible(*args): return _hk_classes.hk_reportsection_get_reportdatavisible(*args)

class hk_reportsectionPtr(hk_reportsection):
    def __init__(self, this):
        _swig_setattr(self, hk_reportsection, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_reportsection, 'thisown', 0)
        _swig_setattr(self, hk_reportsection,self.__class__,hk_reportsection)
_hk_classes.hk_reportsection_swigregister(hk_reportsectionPtr)

hk_reportsection_add_sectionreplacefunctiontype = _hk_classes.hk_reportsection_add_sectionreplacefunctiontype

hk_reportsection_sectionreplacefunctionlist = _hk_classes.hk_reportsection_sectionreplacefunctionlist

hk_reportsection_add_sectioncountfunctiontype = _hk_classes.hk_reportsection_add_sectioncountfunctiontype

hk_reportsection_sectioncountfunctionlist = _hk_classes.hk_reportsection_sectioncountfunctionlist

class hk_reportsectionpair(hk_class):
    __swig_setmethods__ = {}
    for _s in [hk_class]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_reportsectionpair, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_class]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_reportsectionpair, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C hk_reportsectionpair instance at %s>" % (self.this,)
    def __del__(self, destroy=_hk_classes.delete_hk_reportsectionpair):
        try:
            if self.thisown: destroy(self)
        except: pass
    def headersection(*args): return _hk_classes.hk_reportsectionpair_headersection(*args)
    def footersection(*args): return _hk_classes.hk_reportsectionpair_footersection(*args)
    def set_sections(*args): return _hk_classes.hk_reportsectionpair_set_sections(*args)
    def init_sections(*args): return _hk_classes.hk_reportsectionpair_init_sections(*args)
    def set_columnname(*args): return _hk_classes.hk_reportsectionpair_set_columnname(*args)
    def set_ascending_order(*args): return _hk_classes.hk_reportsectionpair_set_ascending_order(*args)
    def ascending_order(*args): return _hk_classes.hk_reportsectionpair_ascending_order(*args)
    def columnname(*args): return _hk_classes.hk_reportsectionpair_columnname(*args)

class hk_reportsectionpairPtr(hk_reportsectionpair):
    def __init__(self, this):
        _swig_setattr(self, hk_reportsectionpair, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_reportsectionpair, 'thisown', 0)
        _swig_setattr(self, hk_reportsectionpair,self.__class__,hk_reportsectionpair)
_hk_classes.hk_reportsectionpair_swigregister(hk_reportsectionpairPtr)

class hk_reportdata(hk_dsdatavisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_reportdata, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_reportdata, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C hk_reportdata instance at %s>" % (self.this,)
    def set_data(*args): return _hk_classes.hk_reportdata_set_data(*args)
    def data(*args): return _hk_classes.hk_reportdata_data(*args)
    def set_beforedata(*args): return _hk_classes.hk_reportdata_set_beforedata(*args)
    def set_afterdata(*args): return _hk_classes.hk_reportdata_set_afterdata(*args)
    def beforedata(*args): return _hk_classes.hk_reportdata_beforedata(*args)
    def afterdata(*args): return _hk_classes.hk_reportdata_afterdata(*args)
    def actual_string(*args): return _hk_classes.hk_reportdata_actual_string(*args)
    def count(*args): return _hk_classes.hk_reportdata_count(*args)
    def set_runningcount(*args): return _hk_classes.hk_reportdata_set_runningcount(*args)
    def runningcount(*args): return _hk_classes.hk_reportdata_runningcount(*args)
    def font(*args): return _hk_classes.hk_reportdata_font(*args)
    def set_datacountfunction(*args): return _hk_classes.hk_reportdata_set_datacountfunction(*args)
    def datacountfunctionstring(*args): return _hk_classes.hk_reportdata_datacountfunctionstring(*args)
    def datacountfunction(*args): return _hk_classes.hk_reportdata_datacountfunction(*args)
    def set_topline(*args): return _hk_classes.hk_reportdata_set_topline(*args)
    def set_bottomline(*args): return _hk_classes.hk_reportdata_set_bottomline(*args)
    def set_leftline(*args): return _hk_classes.hk_reportdata_set_leftline(*args)
    def set_rightline(*args): return _hk_classes.hk_reportdata_set_rightline(*args)
    def set_diagonalluro(*args): return _hk_classes.hk_reportdata_set_diagonalluro(*args)
    def set_diagonalloru(*args): return _hk_classes.hk_reportdata_set_diagonalloru(*args)
    def diagonalloru(*args): return _hk_classes.hk_reportdata_diagonalloru(*args)
    def topline(*args): return _hk_classes.hk_reportdata_topline(*args)
    def bottomline(*args): return _hk_classes.hk_reportdata_bottomline(*args)
    def leftline(*args): return _hk_classes.hk_reportdata_leftline(*args)
    def rightline(*args): return _hk_classes.hk_reportdata_rightline(*args)
    def diagonalluro(*args): return _hk_classes.hk_reportdata_diagonalluro(*args)
    def set_frame(*args): return _hk_classes.hk_reportdata_set_frame(*args)
    def set_wordbreak(*args): return _hk_classes.hk_reportdata_set_wordbreak(*args)
    def wordbreak(*args): return _hk_classes.hk_reportdata_wordbreak(*args)
    def set_configurefunction(*args): return _hk_classes.hk_reportdata_set_configurefunction(*args)
    def configurefunction(*args): return _hk_classes.hk_reportdata_configurefunction(*args)
    def configurefunctionstring(*args): return _hk_classes.hk_reportdata_configurefunctionstring(*args)
    def savedata(*args): return _hk_classes.hk_reportdata_savedata(*args)
    def loaddata(*args): return _hk_classes.hk_reportdata_loaddata(*args)
    def neutralize_definition(*args): return _hk_classes.hk_reportdata_neutralize_definition(*args)
    __swig_getmethods__["configurefunctionlist"] = lambda x: _hk_classes.hk_reportdata_configurefunctionlist
    if _newclass:configurefunctionlist = staticmethod(_hk_classes.hk_reportdata_configurefunctionlist)
    __swig_getmethods__["datacountfunctionlist"] = lambda x: _hk_classes.hk_reportdata_datacountfunctionlist
    if _newclass:datacountfunctionlist = staticmethod(_hk_classes.hk_reportdata_datacountfunctionlist)
    def set_replacefunction(*args): return _hk_classes.hk_reportdata_set_replacefunction(*args)
    __swig_getmethods__["add_datareplacefunctiontype"] = lambda x: _hk_classes.hk_reportdata_add_datareplacefunctiontype
    if _newclass:add_datareplacefunctiontype = staticmethod(_hk_classes.hk_reportdata_add_datareplacefunctiontype)
    __swig_getmethods__["datareplacefunctionlist"] = lambda x: _hk_classes.hk_reportdata_datareplacefunctionlist
    if _newclass:datareplacefunctionlist = staticmethod(_hk_classes.hk_reportdata_datareplacefunctionlist)
    def reset_count(*args): return _hk_classes.hk_reportdata_reset_count(*args)
    def report(*args): return _hk_classes.hk_reportdata_report(*args)
    def section(*args): return _hk_classes.hk_reportdata_section(*args)
    def lower_widget(*args): return _hk_classes.hk_reportdata_lower_widget(*args)
    def raise_widget(*args): return _hk_classes.hk_reportdata_raise_widget(*args)
    def set_on_print_action(*args): return _hk_classes.hk_reportdata_set_on_print_action(*args)
    def on_print_action(*args): return _hk_classes.hk_reportdata_on_print_action(*args)

class hk_reportdataPtr(hk_reportdata):
    def __init__(self, this):
        _swig_setattr(self, hk_reportdata, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_reportdata, 'thisown', 0)
        _swig_setattr(self, hk_reportdata,self.__class__,hk_reportdata)
_hk_classes.hk_reportdata_swigregister(hk_reportdataPtr)

hk_reportdata_configurefunctionlist = _hk_classes.hk_reportdata_configurefunctionlist

hk_reportdata_datacountfunctionlist = _hk_classes.hk_reportdata_datacountfunctionlist

hk_reportdata_add_datareplacefunctiontype = _hk_classes.hk_reportdata_add_datareplacefunctiontype

hk_reportdata_datareplacefunctionlist = _hk_classes.hk_reportdata_datareplacefunctionlist


currentreportdata = _hk_classes.currentreportdata
class hk_actionquery(hk_data):
    __swig_setmethods__ = {}
    for _s in [hk_data]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_actionquery, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_data]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_actionquery, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C hk_actionquery instance at %s>" % (self.this,)
    def set_sql(*args): return _hk_classes.hk_actionquery_set_sql(*args)
    def sql(*args): return _hk_classes.hk_actionquery_sql(*args)
    def length(*args): return _hk_classes.hk_actionquery_length(*args)
    def execute(*args): return _hk_classes.hk_actionquery_execute(*args)
    def __del__(self, destroy=_hk_classes.delete_hk_actionquery):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_actionqueryPtr(hk_actionquery):
    def __init__(self, this):
        _swig_setattr(self, hk_actionquery, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_actionquery, 'thisown', 0)
        _swig_setattr(self, hk_actionquery,self.__class__,hk_actionquery)
_hk_classes.hk_actionquery_swigregister(hk_actionqueryPtr)

class hk_dsgrid(hk_dsvisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsvisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_dsgrid, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsvisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_dsgrid, name)
    def __repr__(self):
        return "<C hk_dsgrid instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_dsgrid, 'this', _hk_classes.new_hk_dsgrid(*args))
        _swig_setattr(self, hk_dsgrid, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_dsgrid):
        try:
            if self.thisown: destroy(self)
        except: pass
    def gridcolumn(*args): return _hk_classes.hk_dsgrid_gridcolumn(*args)
    def columnscount(*args): return _hk_classes.hk_dsgrid_columnscount(*args)
    def set_gridcolumnwidth(*args): return _hk_classes.hk_dsgrid_set_gridcolumnwidth(*args)
    def set_gridcolumns(*args): return _hk_classes.hk_dsgrid_set_gridcolumns(*args)
    def clear_gridcolumn(*args): return _hk_classes.hk_dsgrid_clear_gridcolumn(*args)
    def set_hold_rowdefinition(*args): return _hk_classes.hk_dsgrid_set_hold_rowdefinition(*args)
    def set_enablingbehaviour(*args): return _hk_classes.hk_dsgrid_set_enablingbehaviour(*args)
    def visible_columns(*args): return _hk_classes.hk_dsgrid_visible_columns(*args)
    def nonvisible_columns(*args): return _hk_classes.hk_dsgrid_nonvisible_columns(*args)
    def save_table(*args): return _hk_classes.hk_dsgrid_save_table(*args)
    def load_table(*args): return _hk_classes.hk_dsgrid_load_table(*args)
    def change_columnposition(*args): return _hk_classes.hk_dsgrid_change_columnposition(*args)
    def set_rowheight(*args): return _hk_classes.hk_dsgrid_set_rowheight(*args)
    def rowheight(*args): return _hk_classes.hk_dsgrid_rowheight(*args)

class hk_dsgridPtr(hk_dsgrid):
    def __init__(self, this):
        _swig_setattr(self, hk_dsgrid, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_dsgrid, 'thisown', 0)
        _swig_setattr(self, hk_dsgrid,self.__class__,hk_dsgrid)
_hk_classes.hk_dsgrid_swigregister(hk_dsgridPtr)

class hk_dsgridcolumn(hk_dsdatavisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_dsgridcolumn, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_dsgridcolumn, name)
    def __repr__(self):
        return "<C hk_dsgridcolumn instance at %s>" % (self.this,)
    columnedit = _hk_classes.hk_dsgridcolumn_columnedit
    columnbool = _hk_classes.hk_dsgridcolumn_columnbool
    columncombo = _hk_classes.hk_dsgridcolumn_columncombo
    def __init__(self, *args):
        _swig_setattr(self, hk_dsgridcolumn, 'this', _hk_classes.new_hk_dsgridcolumn(*args))
        _swig_setattr(self, hk_dsgridcolumn, 'thisown', 1)
    def set_displayname(*args): return _hk_classes.hk_dsgridcolumn_set_displayname(*args)
    def displayname(*args): return _hk_classes.hk_dsgridcolumn_displayname(*args)
    def set_columntype(*args): return _hk_classes.hk_dsgridcolumn_set_columntype(*args)
    def columntype(*args): return _hk_classes.hk_dsgridcolumn_columntype(*args)
    def set_columnwidth(*args): return _hk_classes.hk_dsgridcolumn_set_columnwidth(*args)
    def columnwidth(*args): return _hk_classes.hk_dsgridcolumn_columnwidth(*args)
    def set_listdatasource(*args): return _hk_classes.hk_dsgridcolumn_set_listdatasource(*args)
    def listdatasource(*args): return _hk_classes.hk_dsgridcolumn_listdatasource(*args)
    def listdatasourcename(*args): return _hk_classes.hk_dsgridcolumn_listdatasourcename(*args)
    def set_viewcolumnname(*args): return _hk_classes.hk_dsgridcolumn_set_viewcolumnname(*args)
    def viewcolumnname(*args): return _hk_classes.hk_dsgridcolumn_viewcolumnname(*args)
    def set_listcolumnname(*args): return _hk_classes.hk_dsgridcolumn_set_listcolumnname(*args)
    def listcolumnname(*args): return _hk_classes.hk_dsgridcolumn_listcolumnname(*args)
    def set_listpresentationdatasource(*args): return _hk_classes.hk_dsgridcolumn_set_listpresentationdatasource(*args)
    def listpresentationdatasource(*args): return _hk_classes.hk_dsgridcolumn_listpresentationdatasource(*args)
    def value_at(*args): return _hk_classes.hk_dsgridcolumn_value_at(*args)
    def set_datasource(*args): return _hk_classes.hk_dsgridcolumn_set_datasource(*args)
    def combobox(*args): return _hk_classes.hk_dsgridcolumn_combobox(*args)
    def find(*args): return _hk_classes.hk_dsgridcolumn_find(*args)
    def is_findstring(*args): return _hk_classes.hk_dsgridcolumn_is_findstring(*args)
    def __del__(self, destroy=_hk_classes.delete_hk_dsgridcolumn):
        try:
            if self.thisown: destroy(self)
        except: pass

class hk_dsgridcolumnPtr(hk_dsgridcolumn):
    def __init__(self, this):
        _swig_setattr(self, hk_dsgridcolumn, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_dsgridcolumn, 'thisown', 0)
        _swig_setattr(self, hk_dsgridcolumn,self.__class__,hk_dsgridcolumn)
_hk_classes.hk_dsgridcolumn_swigregister(hk_dsgridcolumnPtr)

class hk_dscombobox(hk_dsdatavisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_dscombobox, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsdatavisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_dscombobox, name)
    def __repr__(self):
        return "<C hk_dscombobox instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_dscombobox, 'this', _hk_classes.new_hk_dscombobox(*args))
        _swig_setattr(self, hk_dscombobox, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_dscombobox):
        try:
            if self.thisown: destroy(self)
        except: pass
    def set_listdatasource(*args): return _hk_classes.hk_dscombobox_set_listdatasource(*args)
    def listdatasource(*args): return _hk_classes.hk_dscombobox_listdatasource(*args)
    def set_viewcolumnname(*args): return _hk_classes.hk_dscombobox_set_viewcolumnname(*args)
    def viewcolumnname(*args): return _hk_classes.hk_dscombobox_viewcolumnname(*args)
    def set_listcolumnname(*args): return _hk_classes.hk_dscombobox_set_listcolumnname(*args)
    def listcolumnname(*args): return _hk_classes.hk_dscombobox_listcolumnname(*args)
    combo = _hk_classes.hk_dscombobox_combo
    selector = _hk_classes.hk_dscombobox_selector
    def set_mode(*args): return _hk_classes.hk_dscombobox_set_mode(*args)
    def mode(*args): return _hk_classes.hk_dscombobox_mode(*args)
    def load_listitems(*args): return _hk_classes.hk_dscombobox_load_listitems(*args)
    def value_at(*args): return _hk_classes.hk_dscombobox_value_at(*args)
    def viewcolumn(*args): return _hk_classes.hk_dscombobox_viewcolumn(*args)
    def listcolumn(*args): return _hk_classes.hk_dscombobox_listcolumn(*args)

class hk_dscomboboxPtr(hk_dscombobox):
    def __init__(self, this):
        _swig_setattr(self, hk_dscombobox, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_dscombobox, 'thisown', 0)
        _swig_setattr(self, hk_dscombobox,self.__class__,hk_dscombobox)
_hk_classes.hk_dscombobox_swigregister(hk_dscomboboxPtr)

class hk_subform(hk_dsvisible):
    __swig_setmethods__ = {}
    for _s in [hk_dsvisible]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, hk_subform, name, value)
    __swig_getmethods__ = {}
    for _s in [hk_dsvisible]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, hk_subform, name)
    def __repr__(self):
        return "<C hk_subform instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, hk_subform, 'this', _hk_classes.new_hk_subform(*args))
        _swig_setattr(self, hk_subform, 'thisown', 1)
    def __del__(self, destroy=_hk_classes.delete_hk_subform):
        try:
            if self.thisown: destroy(self)
        except: pass
    def set_name(*args): return _hk_classes.hk_subform_set_name(*args)
    def name(*args): return _hk_classes.hk_subform_name(*args)
    def subform(*args): return _hk_classes.hk_subform_subform(*args)
    def add_depending_fields(*args): return _hk_classes.hk_subform_add_depending_fields(*args)
    def clear_depending_fields(*args): return _hk_classes.hk_subform_clear_depending_fields(*args)
    def depending_on_fields(*args): return _hk_classes.hk_subform_depending_on_fields(*args)

class hk_subformPtr(hk_subform):
    def __init__(self, this):
        _swig_setattr(self, hk_subform, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hk_subform, 'thisown', 0)
        _swig_setattr(self, hk_subform,self.__class__,hk_subform)
_hk_classes.hk_subform_swigregister(hk_subformPtr)


