import _guppi
import _g_useful

class GuppiStream:    
    def __init__(self, filename, _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_useful.guppi_stream_open_file(filename)
        
    def sequential_mode(self, ):
        """Autogenerated from C function:
           bool guppi_stream_sequential_mode(self, )"""
        
        _ret = _g_useful.guppi_stream_sequential_mode(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_sequential_mode(self, ):
        """Autogenerated from C function:
           none guppi_stream_set_sequential_mode(self, )"""
        
        _ret = _g_useful.guppi_stream_set_sequential_mode(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def eol_comment(self, ):
        """Autogenerated from C function:
           const_string guppi_stream_eol_comment(self, )"""
        
        _ret = _g_useful.guppi_stream_eol_comment(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_eol_comment(self, eol_comment):
        """Autogenerated from C function:
           none guppi_stream_set_eol_comment(self, string eol_comment)"""
        
        _ret = _g_useful.guppi_stream_set_eol_comment(self._o, eol_comment)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def ml_comment_start(self, ):
        """Autogenerated from C function:
           const_string guppi_stream_ml_comment_start(self, )"""
        
        _ret = _g_useful.guppi_stream_ml_comment_start(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_ml_comment_start(self, ml_comment_start):
        """Autogenerated from C function:
           none guppi_stream_set_ml_comment_start(self, string ml_comment_start)"""
        
        _ret = _g_useful.guppi_stream_set_ml_comment_start(self._o, ml_comment_start)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def ml_comment_end(self, ):
        """Autogenerated from C function:
           const_string guppi_stream_ml_comment_end(self, )"""
        
        _ret = _g_useful.guppi_stream_ml_comment_end(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_ml_comment_end(self, ml_comment_end):
        """Autogenerated from C function:
           none guppi_stream_set_ml_comment_end(self, string ml_comment_end)"""
        
        _ret = _g_useful.guppi_stream_set_ml_comment_end(self._o, ml_comment_end)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def quote_start(self, ):
        """Autogenerated from C function:
           char guppi_stream_quote_start(self, )"""
        
        _ret = _g_useful.guppi_stream_quote_start(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def quote_end(self, ):
        """Autogenerated from C function:
           char guppi_stream_quote_end(self, )"""
        
        _ret = _g_useful.guppi_stream_quote_end(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_quote_start(self, c):
        """Autogenerated from C function:
           none guppi_stream_set_quote_start(self, char c)"""
        
        _ret = _g_useful.guppi_stream_set_quote_start(self._o, c)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_quote_end(self, c):
        """Autogenerated from C function:
           none guppi_stream_set_quote_end(self, char c)"""
        
        _ret = _g_useful.guppi_stream_set_quote_end(self._o, c)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def source(self, ):
        """Autogenerated from C function:
           const_string guppi_stream_source(self, )"""
        
        _ret = _g_useful.guppi_stream_source(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def number_of_lines(self, ):
        """Autogenerated from C function:
           int guppi_stream_number_of_lines(self, )"""
        
        _ret = _g_useful.guppi_stream_number_of_lines(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def estimated_number_of_lines(self, ):
        """Autogenerated from C function:
           int guppi_stream_estimated_number_of_lines(self, )"""
        
        _ret = _g_useful.guppi_stream_estimated_number_of_lines(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def number_of_preloaded_lines(self, ):
        """Autogenerated from C function:
           int guppi_stream_number_of_preloaded_lines(self, )"""
        
        _ret = _g_useful.guppi_stream_number_of_preloaded_lines(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def load_some_lines(self, ):
        """Autogenerated from C function:
           none guppi_stream_load_some_lines(self, )"""
        
        _ret = _g_useful.guppi_stream_load_some_lines(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def load_more_lines(self, ):
        """Autogenerated from C function:
           none guppi_stream_load_more_lines(self, )"""
        
        _ret = _g_useful.guppi_stream_load_more_lines(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get_line(self, line_no):
        """Autogenerated from C function:
           const_string guppi_stream_get_line(self, int line_no)"""
        
        _ret = _g_useful.guppi_stream_get_line(self._o, line_no)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get_marked_line(self, line_no):
        """Autogenerated from C function:
           const_string guppi_stream_get_marked_line(self, int line_no)"""
        
        _ret = _g_useful.guppi_stream_get_marked_line(self._o, line_no)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get_sanitized_line(self, line_no):
        """Autogenerated from C function:
           const_string guppi_stream_get_sanitized_line(self, int line_no)"""
        
        _ret = _g_useful.guppi_stream_get_sanitized_line(self._o, line_no)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    


def unimplemented_function_dialog(function_name):
    """Autogenerated from C function:
       none guppi_unimplemented_function_dialog(string function_name)"""
    _ret = _g_useful.guppi_unimplemented_function_dialog(function_name)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def exit():
    """Autogenerated from C function:
       none guppi_exit()"""
    _ret = _g_useful.guppi_exit()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def abort():
    """Autogenerated from C function:
       none guppi_abort()"""
    _ret = _g_useful.guppi_abort()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def set_monitor_dpi(x_dpi, y_dpi):
    """Autogenerated from C function:
       none guppi_set_monitor_dpi(double x_dpi, double y_dpi)"""
    _ret = _g_useful.guppi_set_monitor_dpi(x_dpi, y_dpi)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def pt2in(x):
    """Autogenerated from C function:
       double guppi_pt2in(double x)"""
    _ret = _g_useful.guppi_pt2in(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def in2pt(x):
    """Autogenerated from C function:
       double guppi_in2pt(double x)"""
    _ret = _g_useful.guppi_in2pt(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def pt2cm(x):
    """Autogenerated from C function:
       double guppi_pt2cm(double x)"""
    _ret = _g_useful.guppi_pt2cm(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def cm2pt(x):
    """Autogenerated from C function:
       double guppi_cm2pt(double x)"""
    _ret = _g_useful.guppi_cm2pt(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def pt2mm(x):
    """Autogenerated from C function:
       double guppi_pt2mm(double x)"""
    _ret = _g_useful.guppi_pt2mm(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def mm2pt(x):
    """Autogenerated from C function:
       double guppi_mm2pt(double x)"""
    _ret = _g_useful.guppi_mm2pt(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def pt2pc(x):
    """Autogenerated from C function:
       double guppi_pt2pc(double x)"""
    _ret = _g_useful.guppi_pt2pc(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def pc2pt(x):
    """Autogenerated from C function:
       double guppi_pc2pt(double x)"""
    _ret = _g_useful.guppi_pc2pt(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def x_pt2px(x):
    """Autogenerated from C function:
       double guppi_x_pt2px(double x)"""
    _ret = _g_useful.guppi_x_pt2px(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def x_px2pt(x):
    """Autogenerated from C function:
       double guppi_x_px2pt(double x)"""
    _ret = _g_useful.guppi_x_px2pt(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def y_pt2px(x):
    """Autogenerated from C function:
       double guppi_y_pt2px(double x)"""
    _ret = _g_useful.guppi_y_pt2px(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def y_px2pt(x):
    """Autogenerated from C function:
       double guppi_y_px2pt(double x)"""
    _ret = _g_useful.guppi_y_px2pt(x)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def logo_graphic_path():
    """Autogenerated from C function:
       const_string guppi_logo_graphic_path()"""
    _ret = _g_useful.guppi_logo_graphic_path()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def glade_path(filename):
    """Autogenerated from C function:
       const_string guppi_glade_path(string filename)"""
    _ret = _g_useful.guppi_glade_path(filename)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def gnome_guile_repl_path():
    """Autogenerated from C function:
       const_string gnome_guile_repl_path()"""
    _ret = _g_useful.gnome_guile_repl_path()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def plug_in_path_set(path):
    """Autogenerated from C function:
       none guppi_plug_in_path_set(string path)"""
    _ret = _g_useful.guppi_plug_in_path_set(path)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def plug_in_path_prepend(path):
    """Autogenerated from C function:
       none guppi_plug_in_path_prepend(string path)"""
    _ret = _g_useful.guppi_plug_in_path_prepend(path)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def plug_in_path_append(path):
    """Autogenerated from C function:
       none guppi_plug_in_path_append(string path)"""
    _ret = _g_useful.guppi_plug_in_path_append(path)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def plug_in_path_reset_to_default():
    """Autogenerated from C function:
       none guppi_plug_in_path_reset_to_default()"""
    _ret = _g_useful.guppi_plug_in_path_reset_to_default()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def plug_in_load_all():
    """Autogenerated from C function:
       none guppi_plug_in_load_all()"""
    _ret = _g_useful.guppi_plug_in_load_all()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def plug_in_exists(type, code):
    """Autogenerated from C function:
       bool guppi_plug_in_exists(const_string type, const_string code)"""
    _ret = _g_useful.guppi_plug_in_exists(type, code)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def plug_in_is_loaded(type, code):
    """Autogenerated from C function:
       bool guppi_plug_in_is_loaded(const_string type, const_string code)"""
    _ret = _g_useful.guppi_plug_in_is_loaded(type, code)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def plug_in_force_load(type, code):
    """Autogenerated from C function:
       none guppi_plug_in_force_load(const_string type, const_string code)"""
    _ret = _g_useful.guppi_plug_in_force_load(type, code)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def splash_create():
    """Autogenerated from C function:
       none guppi_splash_create()"""
    _ret = _g_useful.guppi_splash_create()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def splash_destroy():
    """Autogenerated from C function:
       none guppi_splash_destroy()"""
    _ret = _g_useful.guppi_splash_destroy()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def splash_message(line1, line2):
    """Autogenerated from C function:
       none guppi_splash_message(string line1, string line2)"""
    _ret = _g_useful.guppi_splash_message(line1, line2)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def stream_open_file(filename):
    """Autogenerated from C function:
       GuppiStream guppi_stream_open_file(string filename)"""
    _ret = _g_useful.guppi_stream_open_file(filename)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def string_is_boolean(s):
    """Autogenerated from C function:
       bool guppi_string_is_boolean(string s)"""
    _ret = _g_useful.guppi_string_is_boolean(s)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def string2boolean(s):
    """Autogenerated from C function:
       bool guppi_string2boolean(string s)"""
    _ret = _g_useful.guppi_string2boolean(s)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def string_is_int(s):
    """Autogenerated from C function:
       bool guppi_string_is_int(string s)"""
    _ret = _g_useful.guppi_string_is_int(s)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def string_is_number(s):
    """Autogenerated from C function:
       bool guppi_string_is_number(string s)"""
    _ret = _g_useful.guppi_string_is_number(s)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def version():
    """Autogenerated from C function:
       const_string guppi_version()"""
    _ret = _g_useful.guppi_version()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def version_major():
    """Autogenerated from C function:
       int guppi_version_major()"""
    _ret = _g_useful.guppi_version_major()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def version_minor():
    """Autogenerated from C function:
       int guppi_version_minor()"""
    _ret = _g_useful.guppi_version_minor()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def version_micro():
    """Autogenerated from C function:
       int guppi_version_micro()"""
    _ret = _g_useful.guppi_version_micro()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret
import _g_data

class GuppiData:    
    def __init__(self, filename, _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_data.guppi_data_read_xml_file(filename)
        
    def get_type_name(self, ):
        """Autogenerated from C function:
           const_string guppi_data_get_type_name(self, )"""
        
        _ret = _g_data.guppi_data_get_type_name(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get_impl_name(self, ):
        """Autogenerated from C function:
           const_string guppi_data_get_impl_name(self, )"""
        
        _ret = _g_data.guppi_data_get_impl_name(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get_label(self, ):
        """Autogenerated from C function:
           const_string guppi_data_get_label(self, )"""
        
        _ret = _g_data.guppi_data_get_label(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_label(self, label):
        """Autogenerated from C function:
           none guppi_data_set_label(self, string label)"""
        
        _ret = _g_data.guppi_data_set_label(self._o, label)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def is_read_only(self, ):
        """Autogenerated from C function:
           bool guppi_data_is_read_only(self, )"""
        
        _ret = _g_data.guppi_data_is_read_only(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def copy(self, ):
        """Autogenerated from C function:
           GuppiData guppi_data_copy(self, )"""
        
        _ret = _g_data.guppi_data_copy(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get_size_in_bytes(self, ):
        """Autogenerated from C function:
           int guppi_data_get_size_in_bytes(self, )"""
        
        _ret = _g_data.guppi_data_get_size_in_bytes(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def spew_xml(self, ):
        """Autogenerated from C function:
           none guppi_data_spew_xml(self, )"""
        
        _ret = _g_data.guppi_data_spew_xml(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def write_xml_file(self, filename):
        """Autogenerated from C function:
           none guppi_data_write_xml_file(self, string filename)"""
        
        _ret = _g_data.guppi_data_write_xml_file(self._o, filename)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiDateIndexed(GuppiData):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        raise ValueError, "Class does not have a constructor."
        

class GuppiPriceSeries(GuppiDateIndexed):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        raise ValueError, "Class does not have a constructor."
        

class GuppiSeqData(GuppiData):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_data.guppi_seq_data_new()
        
    def get(self, index):
        """Autogenerated from C function:
           GuppiData guppi_seq_data_get(self, int index)"""
        
        _ret = _g_data.guppi_seq_data_get(self._o, index)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set(self, index, data):
        """Autogenerated from C function:
           none guppi_seq_data_set(self, int index, GuppiData data)"""
        data = getattr(data, '_o', data)
        _ret = _g_data.guppi_seq_data_set(self._o, index, data)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def prepend(self, data):
        """Autogenerated from C function:
           none guppi_seq_data_prepend(self, GuppiData data)"""
        data = getattr(data, '_o', data)
        _ret = _g_data.guppi_seq_data_prepend(self._o, data)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def append(self, data):
        """Autogenerated from C function:
           none guppi_seq_data_append(self, GuppiData data)"""
        data = getattr(data, '_o', data)
        _ret = _g_data.guppi_seq_data_append(self._o, data)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def insert(self, index, data):
        """Autogenerated from C function:
           none guppi_seq_data_insert(self, int index, GuppiData data)"""
        data = getattr(data, '_o', data)
        _ret = _g_data.guppi_seq_data_insert(self._o, index, data)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiSeq(GuppiData):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        raise ValueError, "Class does not have a constructor."
        
    def size_hint(self, size):
        """Autogenerated from C function:
           none guppi_seq_size_hint(self, size size)"""
        
        _ret = _g_data.guppi_seq_size_hint(self._o, size)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def min_index(self, ):
        """Autogenerated from C function:
           int guppi_seq_min_index(self, )"""
        
        _ret = _g_data.guppi_seq_min_index(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def max_index(self, ):
        """Autogenerated from C function:
           int guppi_seq_max_index(self, )"""
        
        _ret = _g_data.guppi_seq_max_index(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def size(self, ):
        """Autogenerated from C function:
           size guppi_seq_size(self, )"""
        
        _ret = _g_data.guppi_seq_size(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def count(self, ):
        """Autogenerated from C function:
           size guppi_seq_count(self, )"""
        
        _ret = _g_data.guppi_seq_count(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def empty(self, ):
        """Autogenerated from C function:
           bool guppi_seq_empty(self, )"""
        
        _ret = _g_data.guppi_seq_empty(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def nonempty(self, ):
        """Autogenerated from C function:
           bool guppi_seq_nonempty(self, )"""
        
        _ret = _g_data.guppi_seq_nonempty(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def absent(self, ):
        """Autogenerated from C function:
           bool guppi_seq_absent(self, )"""
        
        _ret = _g_data.guppi_seq_absent(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def present(self, ):
        """Autogenerated from C function:
           bool guppi_seq_present(self, )"""
        
        _ret = _g_data.guppi_seq_present(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def in_bounds(self, index):
        """Autogenerated from C function:
           bool guppi_seq_in_bounds(self, int index)"""
        
        _ret = _g_data.guppi_seq_in_bounds(self._o, index)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def contains_bounds(self, seq2):
        """Autogenerated from C function:
           bool guppi_seq_contains_bounds(self, GuppiSeq seq2)"""
        seq2 = getattr(seq2, '_o', seq2)
        _ret = _g_data.guppi_seq_contains_bounds(self._o, seq2)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def equal_bounds(self, seq2):
        """Autogenerated from C function:
           bool guppi_seq_equal_bounds(self, GuppiSeq seq2)"""
        seq2 = getattr(seq2, '_o', seq2)
        _ret = _g_data.guppi_seq_equal_bounds(self._o, seq2)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def shift_indices(self, delta):
        """Autogenerated from C function:
           none guppi_seq_shift_indices(self, int delta)"""
        
        _ret = _g_data.guppi_seq_shift_indices(self._o, delta)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_min_index(self, new_min):
        """Autogenerated from C function:
           none guppi_seq_set_min_index(self, int new_min)"""
        
        _ret = _g_data.guppi_seq_set_min_index(self._o, new_min)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_max_index(self, new_max):
        """Autogenerated from C function:
           none guppi_seq_set_max_index(self, int new_max)"""
        
        _ret = _g_data.guppi_seq_set_max_index(self._o, new_max)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def validate(self, str):
        """Autogenerated from C function:
           bool guppi_seq_validate(self, string str)"""
        
        _ret = _g_data.guppi_seq_validate(self._o, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get_string(self, index):
        """Autogenerated from C function:
           string guppi_seq_get_string(self, int index)"""
        
        _ret = _g_data.guppi_seq_get_string(self._o, index)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_from_string(self, index, str):
        """Autogenerated from C function:
           none guppi_seq_set_from_string(self, int index, string str)"""
        
        _ret = _g_data.guppi_seq_set_from_string(self._o, index, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def insert_from_string(self, index, str):
        """Autogenerated from C function:
           none guppi_seq_insert_from_string(self, int index, string str)"""
        
        _ret = _g_data.guppi_seq_insert_from_string(self._o, index, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def delete(self, index):
        """Autogenerated from C function:
           none guppi_seq_delete(self, int index)"""
        
        _ret = _g_data.guppi_seq_delete(self._o, index)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def delete_many(self, index, count):
        """Autogenerated from C function:
           none guppi_seq_delete_many(self, int index, size count)"""
        
        _ret = _g_data.guppi_seq_delete_many(self._o, index, count)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def delete_range(self, i0, i1):
        """Autogenerated from C function:
           none guppi_seq_delete_range(self, int i0, int i1)"""
        
        _ret = _g_data.guppi_seq_delete_range(self._o, i0, i1)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def grow_to_include(self, index):
        """Autogenerated from C function:
           none guppi_seq_grow_to_include(self, int index)"""
        
        _ret = _g_data.guppi_seq_grow_to_include(self._o, index)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def grow_to_include_range(self, i0, i1):
        """Autogenerated from C function:
           none guppi_seq_grow_to_include_range(self, int i0, int i1)"""
        
        _ret = _g_data.guppi_seq_grow_to_include_range(self._o, i0, i1)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def grow_to_overlap(self, other_seq):
        """Autogenerated from C function:
           none guppi_seq_grow_to_overlap(self, GuppiSeq other_seq)"""
        other_seq = getattr(other_seq, '_o', other_seq)
        _ret = _g_data.guppi_seq_grow_to_overlap(self._o, other_seq)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def has_missing(self, ):
        """Autogenerated from C function:
           bool guppi_seq_has_missing(self, )"""
        
        _ret = _g_data.guppi_seq_has_missing(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def missing_count(self, ):
        """Autogenerated from C function:
           size guppi_seq_missing_count(self, )"""
        
        _ret = _g_data.guppi_seq_missing_count(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def missing(self, i):
        """Autogenerated from C function:
           bool guppi_seq_missing(self, int i)"""
        
        _ret = _g_data.guppi_seq_missing(self._o, i)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_missing(self, i):
        """Autogenerated from C function:
           none guppi_seq_set_missing(self, int i)"""
        
        _ret = _g_data.guppi_seq_set_missing(self._o, i)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def insert_missing(self, i):
        """Autogenerated from C function:
           none guppi_seq_insert_missing(self, int i)"""
        
        _ret = _g_data.guppi_seq_insert_missing(self._o, i)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def prepend_missing(self, ):
        """Autogenerated from C function:
           none guppi_seq_prepend_missing(self, )"""
        
        _ret = _g_data.guppi_seq_prepend_missing(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def append_missing(self, ):
        """Autogenerated from C function:
           none guppi_seq_append_missing(self, )"""
        
        _ret = _g_data.guppi_seq_append_missing(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiSeqScalar(GuppiSeq):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_data.guppi_seq_scalar_new()
        
    def get(self, index):
        """Autogenerated from C function:
           double guppi_seq_scalar_get(self, int index)"""
        
        _ret = _g_data.guppi_seq_scalar_get(self._o, index)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set(self, index, value):
        """Autogenerated from C function:
           none guppi_seq_scalar_set(self, int index, double value)"""
        
        _ret = _g_data.guppi_seq_scalar_set(self._o, index, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def prepend(self, value):
        """Autogenerated from C function:
           none guppi_seq_scalar_prepend(self, double value)"""
        
        _ret = _g_data.guppi_seq_scalar_prepend(self._o, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def prepend_repeating(self, value, count):
        """Autogenerated from C function:
           none guppi_seq_scalar_prepend_repeating(self, double value, size count)"""
        
        _ret = _g_data.guppi_seq_scalar_prepend_repeating(self._o, value, count)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def append(self, value):
        """Autogenerated from C function:
           none guppi_seq_scalar_append(self, double value)"""
        
        _ret = _g_data.guppi_seq_scalar_append(self._o, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def append_repeating(self, value, count):
        """Autogenerated from C function:
           none guppi_seq_scalar_append_repeating(self, double value, size count)"""
        
        _ret = _g_data.guppi_seq_scalar_append_repeating(self._o, value, count)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def insert(self, index, value):
        """Autogenerated from C function:
           none guppi_seq_scalar_insert(self, int index, double value)"""
        
        _ret = _g_data.guppi_seq_scalar_insert(self._o, index, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def insert_repeating(self, index, value, count):
        """Autogenerated from C function:
           none guppi_seq_scalar_insert_repeating(self, int index, double value, size count)"""
        
        _ret = _g_data.guppi_seq_scalar_insert_repeating(self._o, index, value, count)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def min(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_min(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_min(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def max(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_max(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_max(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def sum(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_sum(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_sum(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def sum_abs(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_sum_abs(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_sum_abs(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def mean(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_mean(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_mean(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def var(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_var(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_var(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def vars(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_vars(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_vars(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def sdev(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_sdev(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_sdev(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def sdevs(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_sdevs(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_sdevs(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def q1(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_q1(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_q1(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def median(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_median(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_median(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def q3(self, ):
        """Autogenerated from C function:
           double guppi_seq_scalar_q3(self, )"""
        
        _ret = _g_data.guppi_seq_scalar_q3(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def percentile(self, p):
        """Autogenerated from C function:
           double guppi_seq_scalar_percentile(self, double p)"""
        
        _ret = _g_data.guppi_seq_scalar_percentile(self._o, p)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiSeqString(GuppiSeq):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_data.guppi_seq_string_new()
        
    def get(self, index):
        """Autogenerated from C function:
           const_string guppi_seq_string_get(self, int index)"""
        
        _ret = _g_data.guppi_seq_string_get(self._o, index)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set(self, index, str):
        """Autogenerated from C function:
           none guppi_seq_string_set(self, int index, string str)"""
        
        _ret = _g_data.guppi_seq_string_set(self._o, index, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def prepend(self, str):
        """Autogenerated from C function:
           none guppi_seq_string_prepend(self, string str)"""
        
        _ret = _g_data.guppi_seq_string_prepend(self._o, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def append(self, str):
        """Autogenerated from C function:
           none guppi_seq_string_append(self, string str)"""
        
        _ret = _g_data.guppi_seq_string_append(self._o, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def insert(self, index, str):
        """Autogenerated from C function:
           none guppi_seq_string_insert(self, int index, string str)"""
        
        _ret = _g_data.guppi_seq_string_insert(self._o, index, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def lookup(self, str):
        """Autogenerated from C function:
           int guppi_seq_string_lookup(self, string str)"""
        
        _ret = _g_data.guppi_seq_string_lookup(self._o, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def contains(self, str):
        """Autogenerated from C function:
           bool guppi_seq_string_contains(self, string str)"""
        
        _ret = _g_data.guppi_seq_string_contains(self._o, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def distinct_values(self, ):
        """Autogenerated from C function:
           size guppi_seq_string_distinct_values(self, )"""
        
        _ret = _g_data.guppi_seq_string_distinct_values(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiCategory(GuppiData):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_data.guppi_category_new()
        
    def size(self, ):
        """Autogenerated from C function:
           size guppi_category_size(self, )"""
        
        _ret = _g_data.guppi_category_size(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def min_code(self, ):
        """Autogenerated from C function:
           int guppi_category_min_code(self, )"""
        
        _ret = _g_data.guppi_category_min_code(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def max_code(self, ):
        """Autogenerated from C function:
           int guppi_category_max_code(self, )"""
        
        _ret = _g_data.guppi_category_max_code(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def unused_code(self, ):
        """Autogenerated from C function:
           int guppi_category_unused_code(self, )"""
        
        _ret = _g_data.guppi_category_unused_code(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def define(self, str, code):
        """Autogenerated from C function:
           bool guppi_category_define(self, string str, int code)"""
        
        _ret = _g_data.guppi_category_define(self._o, str, code)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def add_by_name(self, str):
        """Autogenerated from C function:
           int guppi_category_add_by_name(self, string str)"""
        
        _ret = _g_data.guppi_category_add_by_name(self._o, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def contains(self, str):
        """Autogenerated from C function:
           bool guppi_category_contains(self, string str)"""
        
        _ret = _g_data.guppi_category_contains(self._o, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def contains_code(self, code):
        """Autogenerated from C function:
           bool guppi_category_contains_code(self, int code)"""
        
        _ret = _g_data.guppi_category_contains_code(self._o, code)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def find_by_name(self, str):
        """Autogenerated from C function:
           int guppi_category_find_by_name(self, string str)"""
        
        _ret = _g_data.guppi_category_find_by_name(self._o, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def find_by_code(self, code):
        """Autogenerated from C function:
           const_string guppi_category_find_by_code(self, int code)"""
        
        _ret = _g_data.guppi_category_find_by_code(self._o, code)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def rename(self, code, str):
        """Autogenerated from C function:
           bool guppi_category_rename(self, int code, string str)"""
        
        _ret = _g_data.guppi_category_rename(self._o, code, str)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiStruct(GuppiData):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_data.guppi_struct_new()
        
    def get_field_names(self, ):
        """Autogenerated from C function:
           stringv guppi_struct_get_field_names(self, )"""
        
        _ret = _g_data.guppi_struct_get_field_names(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def size(self, ):
        """Autogenerated from C function:
           size guppi_struct_size(self, )"""
        
        _ret = _g_data.guppi_struct_size(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get(self, field):
        """Autogenerated from C function:
           GuppiData guppi_struct_get(self, string field)"""
        
        _ret = _g_data.guppi_struct_get(self._o, field)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set(self, field, data):
        """Autogenerated from C function:
           none guppi_struct_set(self, string field, GuppiData data)"""
        data = getattr(data, '_o', data)
        _ret = _g_data.guppi_struct_set(self._o, field, data)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def add_free_field(self, field):
        """Autogenerated from C function:
           none guppi_struct_add_free_field(self, string field)"""
        
        _ret = _g_data.guppi_struct_add_free_field(self._o, field)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiDataTree:    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_data.guppi_data_tree_new()
        
    def add(self, data):
        """Autogenerated from C function:
           none guppi_data_tree_add(self, GuppiData data)"""
        data = getattr(data, '_o', data)
        _ret = _g_data.guppi_data_tree_add(self._o, data)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def add_beside(self, data, data_to_add):
        """Autogenerated from C function:
           none guppi_data_tree_add_beside(self, GuppiData data, GuppiData data_to_add)"""
        data = getattr(data, '_o', data)
        data_to_add = getattr(data_to_add, '_o', data_to_add)
        _ret = _g_data.guppi_data_tree_add_beside(self._o, data, data_to_add)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def add_below(self, data, data_to_add):
        """Autogenerated from C function:
           none guppi_data_tree_add_below(self, GuppiData data, GuppiData data_to_add)"""
        data = getattr(data, '_o', data)
        data_to_add = getattr(data_to_add, '_o', data_to_add)
        _ret = _g_data.guppi_data_tree_add_below(self._o, data, data_to_add)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def remove(self, data):
        """Autogenerated from C function:
           none guppi_data_tree_remove(self, GuppiData data)"""
        data = getattr(data, '_o', data)
        _ret = _g_data.guppi_data_tree_remove(self._o, data)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def size(self, ):
        """Autogenerated from C function:
           size guppi_data_tree_size(self, )"""
        
        _ret = _g_data.guppi_data_tree_size(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def spew(self, ):
        """Autogenerated from C function:
           none guppi_data_tree_spew(self, )"""
        
        _ret = _g_data.guppi_data_tree_spew(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiSeqInteger(GuppiSeq):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_data.guppi_seq_integer_new()
        
    def get(self, index):
        """Autogenerated from C function:
           int guppi_seq_integer_get(self, int index)"""
        
        _ret = _g_data.guppi_seq_integer_get(self._o, index)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set(self, index, value):
        """Autogenerated from C function:
           none guppi_seq_integer_set(self, int index, int value)"""
        
        _ret = _g_data.guppi_seq_integer_set(self._o, index, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_many_dup(self, i0, i1, value):
        """Autogenerated from C function:
           none guppi_seq_integer_set_many_dup(self, int i0, int i1, int value)"""
        
        _ret = _g_data.guppi_seq_integer_set_many_dup(self._o, i0, i1, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_all(self, value):
        """Autogenerated from C function:
           none guppi_seq_integer_set_all(self, int value)"""
        
        _ret = _g_data.guppi_seq_integer_set_all(self._o, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def prepend(self, value):
        """Autogenerated from C function:
           none guppi_seq_integer_prepend(self, int value)"""
        
        _ret = _g_data.guppi_seq_integer_prepend(self._o, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def append(self, value):
        """Autogenerated from C function:
           none guppi_seq_integer_append(self, int value)"""
        
        _ret = _g_data.guppi_seq_integer_append(self._o, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def insert(self, index, value):
        """Autogenerated from C function:
           none guppi_seq_integer_insert(self, int index, int value)"""
        
        _ret = _g_data.guppi_seq_integer_insert(self._o, index, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def min(self, ):
        """Autogenerated from C function:
           int guppi_seq_integer_min(self, )"""
        
        _ret = _g_data.guppi_seq_integer_min(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def max(self, ):
        """Autogenerated from C function:
           int guppi_seq_integer_max(self, )"""
        
        _ret = _g_data.guppi_seq_integer_max(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def frequency(self, value):
        """Autogenerated from C function:
           int guppi_seq_integer_frequency(self, int value)"""
        
        _ret = _g_data.guppi_seq_integer_frequency(self._o, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiSeqBoolean(GuppiSeq):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_data.guppi_seq_boolean_new()
        
    def get(self, index):
        """Autogenerated from C function:
           bool guppi_seq_boolean_get(self, int index)"""
        
        _ret = _g_data.guppi_seq_boolean_get(self._o, index)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set(self, index, value):
        """Autogenerated from C function:
           none guppi_seq_boolean_set(self, int index, bool value)"""
        
        _ret = _g_data.guppi_seq_boolean_set(self._o, index, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_all(self, value):
        """Autogenerated from C function:
           none guppi_seq_boolean_set_all(self, bool value)"""
        
        _ret = _g_data.guppi_seq_boolean_set_all(self._o, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def clear(self, ):
        """Autogenerated from C function:
           none guppi_seq_boolean_clear(self, )"""
        
        _ret = _g_data.guppi_seq_boolean_clear(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def prepend(self, value):
        """Autogenerated from C function:
           none guppi_seq_boolean_prepend(self, bool value)"""
        
        _ret = _g_data.guppi_seq_boolean_prepend(self._o, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def prepend_many(self, value, count):
        """Autogenerated from C function:
           none guppi_seq_boolean_prepend_many(self, bool value, size count)"""
        
        _ret = _g_data.guppi_seq_boolean_prepend_many(self._o, value, count)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def append(self, value):
        """Autogenerated from C function:
           none guppi_seq_boolean_append(self, bool value)"""
        
        _ret = _g_data.guppi_seq_boolean_append(self._o, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def append_many(self, value, count):
        """Autogenerated from C function:
           none guppi_seq_boolean_append_many(self, bool value, size count)"""
        
        _ret = _g_data.guppi_seq_boolean_append_many(self._o, value, count)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def insert(self, index, value):
        """Autogenerated from C function:
           none guppi_seq_boolean_insert(self, int index, bool value)"""
        
        _ret = _g_data.guppi_seq_boolean_insert(self._o, index, value)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def insert_many(self, index, value, count):
        """Autogenerated from C function:
           none guppi_seq_boolean_insert_many(self, int index, bool value, size count)"""
        
        _ret = _g_data.guppi_seq_boolean_insert_many(self._o, index, value, count)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def bitwise_and(self, other_seq):
        """Autogenerated from C function:
           none guppi_seq_boolean_bitwise_and(self, GuppiSeqBoolean other_seq)"""
        other_seq = getattr(other_seq, '_o', other_seq)
        _ret = _g_data.guppi_seq_boolean_bitwise_and(self._o, other_seq)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def bitwise_or(self, other_seq):
        """Autogenerated from C function:
           none guppi_seq_boolean_bitwise_or(self, GuppiSeqBoolean other_seq)"""
        other_seq = getattr(other_seq, '_o', other_seq)
        _ret = _g_data.guppi_seq_boolean_bitwise_or(self._o, other_seq)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def bitwise_xor(self, other_seq):
        """Autogenerated from C function:
           none guppi_seq_boolean_bitwise_xor(self, GuppiSeqBoolean other_seq)"""
        other_seq = getattr(other_seq, '_o', other_seq)
        _ret = _g_data.guppi_seq_boolean_bitwise_xor(self._o, other_seq)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def bitwise_not(self, ):
        """Autogenerated from C function:
           none guppi_seq_boolean_bitwise_not(self, )"""
        
        _ret = _g_data.guppi_seq_boolean_bitwise_not(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def first_true(self, ):
        """Autogenerated from C function:
           int guppi_seq_boolean_first_true(self, )"""
        
        _ret = _g_data.guppi_seq_boolean_first_true(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def next_true(self, index):
        """Autogenerated from C function:
           int guppi_seq_boolean_next_true(self, int index)"""
        
        _ret = _g_data.guppi_seq_boolean_next_true(self._o, index)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def true_count(self, ):
        """Autogenerated from C function:
           size guppi_seq_boolean_true_count(self, )"""
        
        _ret = _g_data.guppi_seq_boolean_true_count(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiCurve(GuppiData):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        raise ValueError, "Class does not have a constructor."
        
    def parameter_lower_bound(self, ):
        """Autogenerated from C function:
           double guppi_curve_parameter_lower_bound(self, )"""
        
        _ret = _g_data.guppi_curve_parameter_lower_bound(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def parameter_upper_bound(self, ):
        """Autogenerated from C function:
           double guppi_curve_parameter_upper_bound(self, )"""
        
        _ret = _g_data.guppi_curve_parameter_upper_bound(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def parameter_in_bounds(self, t):
        """Autogenerated from C function:
           bool guppi_curve_parameter_in_bounds(self, double t)"""
        
        _ret = _g_data.guppi_curve_parameter_in_bounds(self._o, t)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def clamp_parameter(self, t):
        """Autogenerated from C function:
           double guppi_curve_clamp_parameter(self, double t)"""
        
        _ret = _g_data.guppi_curve_clamp_parameter(self._o, t)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def parameter_01(self, t):
        """Autogenerated from C function:
           double guppi_curve_parameter_01(self, double t)"""
        
        _ret = _g_data.guppi_curve_parameter_01(self._o, t)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get_x(self, t):
        """Autogenerated from C function:
           double guppi_curve_get_x(self, double t)"""
        
        _ret = _g_data.guppi_curve_get_x(self._o, t)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get_y(self, t):
        """Autogenerated from C function:
           double guppi_curve_get_y(self, double t)"""
        
        _ret = _g_data.guppi_curve_get_y(self._o, t)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get_x_01(self, t):
        """Autogenerated from C function:
           double guppi_curve_get_x_01(self, double t)"""
        
        _ret = _g_data.guppi_curve_get_x_01(self._o, t)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get_y_01(self, t):
        """Autogenerated from C function:
           double guppi_curve_get_y_01(self, double t)"""
        
        _ret = _g_data.guppi_curve_get_y_01(self._o, t)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiSeqCategorical(GuppiSeqInteger):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_data.guppi_seq_categorical_new()
        
    def category(self, ):
        """Autogenerated from C function:
           GuppiCategory guppi_seq_categorical_category(self, )"""
        
        _ret = _g_data.guppi_seq_categorical_category(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_category(self, cat):
        """Autogenerated from C function:
           none guppi_seq_categorical_set_category(self, GuppiCategory cat)"""
        cat = getattr(cat, '_o', cat)
        _ret = _g_data.guppi_seq_categorical_set_category(self._o, cat)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def get(self, i):
        """Autogenerated from C function:
           const_string guppi_seq_categorical_get(self, int i)"""
        
        _ret = _g_data.guppi_seq_categorical_get(self._o, i)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set(self, i, s):
        """Autogenerated from C function:
           bool guppi_seq_categorical_set(self, int i, string s)"""
        
        _ret = _g_data.guppi_seq_categorical_set(self._o, i, s)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def prepend(self, s):
        """Autogenerated from C function:
           bool guppi_seq_categorical_prepend(self, string s)"""
        
        _ret = _g_data.guppi_seq_categorical_prepend(self._o, s)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def append(self, s):
        """Autogenerated from C function:
           bool guppi_seq_categorical_append(self, string s)"""
        
        _ret = _g_data.guppi_seq_categorical_append(self._o, s)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def insert(self, i, s):
        """Autogenerated from C function:
           bool guppi_seq_categorical_insert(self, int i, string s)"""
        
        _ret = _g_data.guppi_seq_categorical_insert(self._o, i, s)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def frequency(self, s):
        """Autogenerated from C function:
           int guppi_seq_categorical_frequency(self, string s)"""
        
        _ret = _g_data.guppi_seq_categorical_frequency(self._o, s)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def percentage(self, s):
        """Autogenerated from C function:
           double guppi_seq_categorical_percentage(self, string s)"""
        
        _ret = _g_data.guppi_seq_categorical_percentage(self._o, s)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    


def data_read_xml_file(filename):
    """Autogenerated from C function:
       GuppiData guppi_data_read_xml_file(string filename)"""
    _ret = _g_data.guppi_data_read_xml_file(filename)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def struct_new():
    """Autogenerated from C function:
       GuppiData guppi_struct_new()"""
    _ret = _g_data.guppi_struct_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def category_new():
    """Autogenerated from C function:
       GuppiData guppi_category_new()"""
    _ret = _g_data.guppi_category_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def seq_scalar_new():
    """Autogenerated from C function:
       GuppiData guppi_seq_scalar_new()"""
    _ret = _g_data.guppi_seq_scalar_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def seq_integer_new():
    """Autogenerated from C function:
       GuppiData guppi_seq_integer_new()"""
    _ret = _g_data.guppi_seq_integer_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def seq_categorical_new():
    """Autogenerated from C function:
       GuppiData guppi_seq_categorical_new()"""
    _ret = _g_data.guppi_seq_categorical_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def seq_string_new():
    """Autogenerated from C function:
       GuppiData guppi_seq_string_new()"""
    _ret = _g_data.guppi_seq_string_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def seq_boolean_new():
    """Autogenerated from C function:
       GuppiData guppi_seq_boolean_new()"""
    _ret = _g_data.guppi_seq_boolean_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def seq_data_new():
    """Autogenerated from C function:
       GuppiData guppi_seq_data_new()"""
    _ret = _g_data.guppi_seq_data_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def data_tree_new():
    """Autogenerated from C function:
       GuppiDataTree guppi_data_tree_new()"""
    _ret = _g_data.guppi_data_tree_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def data_tree_main():
    """Autogenerated from C function:
       GuppiDataTree guppi_data_tree_main()"""
    _ret = _g_data.guppi_data_tree_main()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret
import _g_plot

class GuppiStyle:    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_plot.guppi_style_new()
        
    def marker_size1(self, ):
        """Autogenerated from C function:
           double guppi_style_marker_size1(self, )"""
        
        _ret = _g_plot.guppi_style_marker_size1(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def marker_size2(self, ):
        """Autogenerated from C function:
           double guppi_style_marker_size2(self, )"""
        
        _ret = _g_plot.guppi_style_marker_size2(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def color(self, ):
        """Autogenerated from C function:
           color guppi_style_color(self, )"""
        
        _ret = _g_plot.guppi_style_color(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def color_dim(self, ):
        """Autogenerated from C function:
           color guppi_style_color_dim(self, )"""
        
        _ret = _g_plot.guppi_style_color_dim(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def color_bright(self, ):
        """Autogenerated from C function:
           color guppi_style_color_bright(self, )"""
        
        _ret = _g_plot.guppi_style_color_bright(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def line_width(self, ):
        """Autogenerated from C function:
           double guppi_style_line_width(self, )"""
        
        _ret = _g_plot.guppi_style_line_width(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_marker_size1(self, x):
        """Autogenerated from C function:
           none guppi_style_set_marker_size1(self, double x)"""
        
        _ret = _g_plot.guppi_style_set_marker_size1(self._o, x)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_marker_size2(self, x):
        """Autogenerated from C function:
           none guppi_style_set_marker_size2(self, double x)"""
        
        _ret = _g_plot.guppi_style_set_marker_size2(self._o, x)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_color(self, x):
        """Autogenerated from C function:
           none guppi_style_set_color(self, color x)"""
        
        _ret = _g_plot.guppi_style_set_color(self._o, x)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_color_dim(self, x):
        """Autogenerated from C function:
           none guppi_style_set_color_dim(self, color x)"""
        
        _ret = _g_plot.guppi_style_set_color_dim(self._o, x)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_color_bright(self, x):
        """Autogenerated from C function:
           none guppi_style_set_color_bright(self, color x)"""
        
        _ret = _g_plot.guppi_style_set_color_bright(self._o, x)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_line_width(self, x):
        """Autogenerated from C function:
           none guppi_style_set_line_width(self, double x)"""
        
        _ret = _g_plot.guppi_style_set_line_width(self._o, x)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def freeze(self, ):
        """Autogenerated from C function:
           none guppi_style_freeze(self, )"""
        
        _ret = _g_plot.guppi_style_freeze(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def thaw(self, ):
        """Autogenerated from C function:
           none guppi_style_thaw(self, )"""
        
        _ret = _g_plot.guppi_style_thaw(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def changed(self, ):
        """Autogenerated from C function:
           none guppi_style_changed(self, )"""
        
        _ret = _g_plot.guppi_style_changed(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def changed_delayed(self, ):
        """Autogenerated from C function:
           none guppi_style_changed_delayed(self, )"""
        
        _ret = _g_plot.guppi_style_changed_delayed(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def flush_changes(self, ):
        """Autogenerated from C function:
           none guppi_style_flush_changes(self, )"""
        
        _ret = _g_plot.guppi_style_flush_changes(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def edit_window(self, ):
        """Autogenerated from C function:
           none guppi_style_edit_window(self, )"""
        
        _ret = _g_plot.guppi_style_edit_window(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiColorGradient:    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_plot.guppi_color_gradient_new()
        
    def value(self, t):
        """Autogenerated from C function:
           color guppi_color_gradient_value(self, double t)"""
        
        _ret = _g_plot.guppi_color_gradient_value(self._o, t)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set2(self, x, y):
        """Autogenerated from C function:
           none guppi_color_gradient_set2(self, color x, color y)"""
        
        _ret = _g_plot.guppi_color_gradient_set2(self._o, x, y)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_fade_in(self, x):
        """Autogenerated from C function:
           none guppi_color_gradient_set_fade_in(self, color x)"""
        
        _ret = _g_plot.guppi_color_gradient_set_fade_in(self._o, x)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_fade_out(self, x):
        """Autogenerated from C function:
           none guppi_color_gradient_set_fade_out(self, color x)"""
        
        _ret = _g_plot.guppi_color_gradient_set_fade_out(self._o, x)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_fire(self, v, a):
        """Autogenerated from C function:
           none guppi_color_gradient_set_fire(self, double v, double a)"""
        
        _ret = _g_plot.guppi_color_gradient_set_fire(self._o, v, a)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_ice(self, v, a):
        """Autogenerated from C function:
           none guppi_color_gradient_set_ice(self, double v, double a)"""
        
        _ret = _g_plot.guppi_color_gradient_set_ice(self._o, v, a)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_thermal(self, v, a):
        """Autogenerated from C function:
           none guppi_color_gradient_set_thermal(self, double v, double a)"""
        
        _ret = _g_plot.guppi_color_gradient_set_thermal(self._o, v, a)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_spectrum(self, v, a):
        """Autogenerated from C function:
           none guppi_color_gradient_set_spectrum(self, double v, double a)"""
        
        _ret = _g_plot.guppi_color_gradient_set_spectrum(self._o, v, a)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiElementView:    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        raise ValueError, "Class does not have a constructor."
        
    def state(self, ):
        """Autogenerated from C function:
           GuppiElementState guppi_element_view_state(self, )"""
        
        _ret = _g_plot.guppi_element_view_state(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_x_axis_marker_type(self, t):
        """Autogenerated from C function:
           none guppi_element_view_set_x_axis_marker_type(self, int t)"""
        
        _ret = _g_plot.guppi_element_view_set_x_axis_marker_type(self._o, t)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_y_axis_marker_type(self, t):
        """Autogenerated from C function:
           none guppi_element_view_set_y_axis_marker_type(self, int t)"""
        
        _ret = _g_plot.guppi_element_view_set_y_axis_marker_type(self._o, t)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def connect(self, s1, v2, s2):
        """Autogenerated from C function:
           none guppi_element_view_connect(self, string s1, GuppiElementView v2, string s2)"""
        v2 = getattr(v2, '_o', v2)
        _ret = _g_plot.guppi_element_view_connect(self._o, s1, v2, s2)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_preferred_x_view(self, ):
        """Autogenerated from C function:
           none guppi_element_view_set_preferred_x_view(self, )"""
        
        _ret = _g_plot.guppi_element_view_set_preferred_x_view(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_preferred_y_view(self, ):
        """Autogenerated from C function:
           none guppi_element_view_set_preferred_y_view(self, )"""
        
        _ret = _g_plot.guppi_element_view_set_preferred_y_view(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_preferred_view(self, ):
        """Autogenerated from C function:
           none guppi_element_view_set_preferred_view(self, )"""
        
        _ret = _g_plot.guppi_element_view_set_preferred_view(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def force_preferred_x_view(self, q):
        """Autogenerated from C function:
           none guppi_element_view_force_preferred_x_view(self, bool q)"""
        
        _ret = _g_plot.guppi_element_view_force_preferred_x_view(self._o, q)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def force_preferred_y_view(self, q):
        """Autogenerated from C function:
           none guppi_element_view_force_preferred_y_view(self, bool q)"""
        
        _ret = _g_plot.guppi_element_view_force_preferred_y_view(self._o, q)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def force_preferred_view(self, q):
        """Autogenerated from C function:
           none guppi_element_view_force_preferred_view(self, bool q)"""
        
        _ret = _g_plot.guppi_element_view_force_preferred_view(self._o, q)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def print_ps_to_file(self, filename):
        """Autogenerated from C function:
           none guppi_element_view_print_ps_to_file(self, string filename)"""
        
        _ret = _g_plot.guppi_element_view_print_ps_to_file(self._o, filename)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def freeze(self, ):
        """Autogenerated from C function:
           none guppi_element_view_freeze(self, )"""
        
        _ret = _g_plot.guppi_element_view_freeze(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def thaw(self, ):
        """Autogenerated from C function:
           none guppi_element_view_thaw(self, )"""
        
        _ret = _g_plot.guppi_element_view_thaw(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiGroupView(GuppiElementView):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        raise ValueError, "Class does not have a constructor."
        
    def has(self, v):
        """Autogenerated from C function:
           bool guppi_group_view_has(self, GuppiElementView v)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_has(self._o, v)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def add(self, v):
        """Autogenerated from C function:
           none guppi_group_view_add(self, GuppiElementView v)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_add(self._o, v)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def remove(self, v):
        """Autogenerated from C function:
           none guppi_group_view_remove(self, GuppiElementView v)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_remove(self._o, v)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def replace(self, v_old, v_new):
        """Autogenerated from C function:
           none guppi_group_view_replace(self, GuppiElementView v_old, GuppiElementView v_new)"""
        v_old = getattr(v_old, '_o', v_old)
        v_new = getattr(v_new, '_o', v_new)
        _ret = _g_plot.guppi_group_view_replace(self._o, v_old, v_new)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def commit_changes(self, ):
        """Autogenerated from C function:
           none guppi_group_view_commit_changes(self, )"""
        
        _ret = _g_plot.guppi_group_view_commit_changes(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def commit_all_changes(self, ):
        """Autogenerated from C function:
           none guppi_group_view_commit_all_changes(self, )"""
        
        _ret = _g_plot.guppi_group_view_commit_all_changes(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_natural_width(self, v):
        """Autogenerated from C function:
           none guppi_group_view_layout_natural_width(self, GuppiElementView v)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_natural_width(self._o, v)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_natural_height(self, v):
        """Autogenerated from C function:
           none guppi_group_view_layout_natural_height(self, GuppiElementView v)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_natural_height(self._o, v)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_left_edge_relative(self, v, percentage):
        """Autogenerated from C function:
           none guppi_group_view_layout_left_edge_relative(self, GuppiElementView v, double percentage)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_left_edge_relative(self._o, v, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_right_edge_relative(self, v, percentage):
        """Autogenerated from C function:
           none guppi_group_view_layout_right_edge_relative(self, GuppiElementView v, double percentage)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_right_edge_relative(self._o, v, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_top_edge_relative(self, v, percentage):
        """Autogenerated from C function:
           none guppi_group_view_layout_top_edge_relative(self, GuppiElementView v, double percentage)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_top_edge_relative(self._o, v, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_bottom_edge_relative(self, v, percentage):
        """Autogenerated from C function:
           none guppi_group_view_layout_bottom_edge_relative(self, GuppiElementView v, double percentage)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_bottom_edge_relative(self._o, v, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_flush_left(self, v, margin):
        """Autogenerated from C function:
           none guppi_group_view_layout_flush_left(self, GuppiElementView v, double margin)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_flush_left(self._o, v, margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_flush_right(self, v, margin):
        """Autogenerated from C function:
           none guppi_group_view_layout_flush_right(self, GuppiElementView v, double margin)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_flush_right(self._o, v, margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_flush_top(self, v, margin):
        """Autogenerated from C function:
           none guppi_group_view_layout_flush_top(self, GuppiElementView v, double margin)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_flush_top(self._o, v, margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_flush_bottom(self, v, margin):
        """Autogenerated from C function:
           none guppi_group_view_layout_flush_bottom(self, GuppiElementView v, double margin)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_flush_bottom(self._o, v, margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_width_relative(self, v, percentage):
        """Autogenerated from C function:
           none guppi_group_view_layout_width_relative(self, GuppiElementView v, double percentage)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_width_relative(self._o, v, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_height_relative(self, v, percentage):
        """Autogenerated from C function:
           none guppi_group_view_layout_height_relative(self, GuppiElementView v, double percentage)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_height_relative(self._o, v, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_center_horizontally(self, v):
        """Autogenerated from C function:
           none guppi_group_view_layout_center_horizontally(self, GuppiElementView v)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_center_horizontally(self._o, v)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_center_vertically(self, v):
        """Autogenerated from C function:
           none guppi_group_view_layout_center_vertically(self, GuppiElementView v)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_center_vertically(self._o, v)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_horizontal_fill(self, v, l_margin, r_margin):
        """Autogenerated from C function:
           none guppi_group_view_layout_horizontal_fill(self, GuppiElementView v, double l_margin, double r_margin)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_horizontal_fill(self._o, v, l_margin, r_margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_vertical_fill(self, v, l_margin, r_margin):
        """Autogenerated from C function:
           none guppi_group_view_layout_vertical_fill(self, GuppiElementView v, double l_margin, double r_margin)"""
        v = getattr(v, '_o', v)
        _ret = _g_plot.guppi_group_view_layout_vertical_fill(self._o, v, l_margin, r_margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_aligned_left_edge(self, a, b):
        """Autogenerated from C function:
           none guppi_group_view_layout_aligned_left_edge(self, GuppiElementView a, GuppiElementView b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_aligned_left_edge(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_aligned_right_edge(self, a, b):
        """Autogenerated from C function:
           none guppi_group_view_layout_aligned_right_edge(self, GuppiElementView a, GuppiElementView b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_aligned_right_edge(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_aligned_top_edge(self, a, b):
        """Autogenerated from C function:
           none guppi_group_view_layout_aligned_top_edge(self, GuppiElementView a, GuppiElementView b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_aligned_top_edge(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_aligned_bottom_edge(self, a, b):
        """Autogenerated from C function:
           none guppi_group_view_layout_aligned_bottom_edge(self, GuppiElementView a, GuppiElementView b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_aligned_bottom_edge(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_horizontally_adjacent(self, left, right, gap):
        """Autogenerated from C function:
           none guppi_group_view_layout_horizontally_adjacent(self, GuppiElementView left, GuppiElementView right, double gap)"""
        left = getattr(left, '_o', left)
        right = getattr(right, '_o', right)
        _ret = _g_plot.guppi_group_view_layout_horizontally_adjacent(self._o, left, right, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_vertically_adjacent(self, top, bot, gap):
        """Autogenerated from C function:
           none guppi_group_view_layout_vertically_adjacent(self, GuppiElementView top, GuppiElementView bot, double gap)"""
        top = getattr(top, '_o', top)
        bot = getattr(bot, '_o', bot)
        _ret = _g_plot.guppi_group_view_layout_vertically_adjacent(self._o, top, bot, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_hbox2(self, left, right, gap):
        """Autogenerated from C function:
           none guppi_group_view_layout_hbox2(self, GuppiElementView left, GuppiElementView right, double gap)"""
        left = getattr(left, '_o', left)
        right = getattr(right, '_o', right)
        _ret = _g_plot.guppi_group_view_layout_hbox2(self._o, left, right, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_hbox3(self, left, center, right, gap):
        """Autogenerated from C function:
           none guppi_group_view_layout_hbox3(self, GuppiElementView left, GuppiElementView center, GuppiElementView right, double gap)"""
        left = getattr(left, '_o', left)
        center = getattr(center, '_o', center)
        right = getattr(right, '_o', right)
        _ret = _g_plot.guppi_group_view_layout_hbox3(self._o, left, center, right, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_vbox2(self, upper, lower, gap):
        """Autogenerated from C function:
           none guppi_group_view_layout_vbox2(self, GuppiElementView upper, GuppiElementView lower, double gap)"""
        upper = getattr(upper, '_o', upper)
        lower = getattr(lower, '_o', lower)
        _ret = _g_plot.guppi_group_view_layout_vbox2(self._o, upper, lower, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_vbox3(self, upper, center, lower, gap):
        """Autogenerated from C function:
           none guppi_group_view_layout_vbox3(self, GuppiElementView upper, GuppiElementView center, GuppiElementView lower, double gap)"""
        upper = getattr(upper, '_o', upper)
        center = getattr(center, '_o', center)
        lower = getattr(lower, '_o', lower)
        _ret = _g_plot.guppi_group_view_layout_vbox3(self._o, upper, center, lower, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_width_ratio(self, a, b, ratio):
        """Autogenerated from C function:
           none guppi_group_view_layout_width_ratio(self, GuppiElementView a, GuppiElementView b, double ratio)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_width_ratio(self._o, a, b, ratio)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_height_ratio(self, a, b, ratio):
        """Autogenerated from C function:
           none guppi_group_view_layout_height_ratio(self, GuppiElementView a, GuppiElementView b, double ratio)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_height_ratio(self._o, a, b, ratio)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_same_width(self, a, b):
        """Autogenerated from C function:
           none guppi_group_view_layout_same_width(self, GuppiElementView a, GuppiElementView b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_same_width(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_same_height(self, a, b):
        """Autogenerated from C function:
           none guppi_group_view_layout_same_height(self, GuppiElementView a, GuppiElementView b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_same_height(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_width_equals_height(self, a, b):
        """Autogenerated from C function:
           none guppi_group_view_layout_width_equals_height(self, GuppiElementView a, GuppiElementView b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_width_equals_height(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_same_size(self, a, b):
        """Autogenerated from C function:
           none guppi_group_view_layout_same_size(self, GuppiElementView a, GuppiElementView b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_same_size(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_same_place(self, a, b):
        """Autogenerated from C function:
           none guppi_group_view_layout_same_place(self, GuppiElementView a, GuppiElementView b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_same_place(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_same_x_center(self, a, b):
        """Autogenerated from C function:
           none guppi_group_view_layout_same_x_center(self, GuppiElementView a, GuppiElementView b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_same_x_center(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def layout_same_y_center(self, a, b):
        """Autogenerated from C function:
           none guppi_group_view_layout_same_y_center(self, GuppiElementView a, GuppiElementView b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_group_view_layout_same_y_center(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiElementState:    
    def __init__(self, type_name, rest, _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_plot.guppi_element_state_newv(type_name, rest)
        
    def label(self, ):
        """Autogenerated from C function:
           const_string guppi_element_state_label(self, )"""
        
        _ret = _g_plot.guppi_element_state_label(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_label(self, s):
        """Autogenerated from C function:
           none guppi_element_state_set_label(self, string s)"""
        
        _ret = _g_plot.guppi_element_state_set_label(self._o, s)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def make_view(self, ):
        """Autogenerated from C function:
           GuppiElementView guppi_element_state_make_view(self, )"""
        
        _ret = _g_plot.guppi_element_state_make_view(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def connect(self, str1, s2, str2):
        """Autogenerated from C function:
           none guppi_element_state_connect(self, string str1, GuppiElementState s2, string str2)"""
        s2 = getattr(s2, '_o', s2)
        _ret = _g_plot.guppi_element_state_connect(self._o, str1, s2, str2)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def spew_xml(self, ):
        """Autogenerated from C function:
           none guppi_element_state_spew_xml(self, )"""
        
        _ret = _g_plot.guppi_element_state_spew_xml(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiGroupState(GuppiElementState):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_plot.guppi_group_state_new()
        

class GuppiLayout:    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_plot.guppi_layout_new()
        
    def natural_width(self, geom):
        """Autogenerated from C function:
           none guppi_layout_natural_width(self, GuppiGeometry geom)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_natural_width(self._o, geom)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def natural_height(self, geom):
        """Autogenerated from C function:
           none guppi_layout_natural_height(self, GuppiGeometry geom)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_natural_height(self._o, geom)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def left_edge_relative(self, geom, percentage):
        """Autogenerated from C function:
           none guppi_layout_left_edge_relative(self, GuppiGeometry geom, double percentage)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_left_edge_relative(self._o, geom, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def right_edge_relative(self, geom, percentage):
        """Autogenerated from C function:
           none guppi_layout_right_edge_relative(self, GuppiGeometry geom, double percentage)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_right_edge_relative(self._o, geom, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def top_edge_relative(self, geom, percentage):
        """Autogenerated from C function:
           none guppi_layout_top_edge_relative(self, GuppiGeometry geom, double percentage)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_top_edge_relative(self._o, geom, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def bottom_edge_relative(self, geom, percentage):
        """Autogenerated from C function:
           none guppi_layout_bottom_edge_relative(self, GuppiGeometry geom, double percentage)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_bottom_edge_relative(self._o, geom, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def flush_left(self, geom, margin):
        """Autogenerated from C function:
           none guppi_layout_flush_left(self, GuppiGeometry geom, double margin)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_flush_left(self._o, geom, margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def flush_right(self, geom, margin):
        """Autogenerated from C function:
           none guppi_layout_flush_right(self, GuppiGeometry geom, double margin)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_flush_right(self._o, geom, margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def flush_top(self, geom, margin):
        """Autogenerated from C function:
           none guppi_layout_flush_top(self, GuppiGeometry geom, double margin)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_flush_top(self._o, geom, margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def flush_bottom(self, geom, margin):
        """Autogenerated from C function:
           none guppi_layout_flush_bottom(self, GuppiGeometry geom, double margin)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_flush_bottom(self._o, geom, margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def width_relative(self, geom, percentage):
        """Autogenerated from C function:
           none guppi_layout_width_relative(self, GuppiGeometry geom, double percentage)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_width_relative(self._o, geom, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def height_relative(self, geom, percentage):
        """Autogenerated from C function:
           none guppi_layout_height_relative(self, GuppiGeometry geom, double percentage)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_height_relative(self._o, geom, percentage)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def center_horizontally(self, geom):
        """Autogenerated from C function:
           none guppi_layout_center_horizontally(self, GuppiGeometry geom)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_center_horizontally(self._o, geom)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def center_vertically(self, geom):
        """Autogenerated from C function:
           none guppi_layout_center_vertically(self, GuppiGeometry geom)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_center_vertically(self._o, geom)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def horizontal_fill(self, geom, l_margin, r_margin):
        """Autogenerated from C function:
           none guppi_layout_horizontal_fill(self, GuppiGeometry geom, double l_margin, double r_margin)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_horizontal_fill(self._o, geom, l_margin, r_margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def vertical_fill(self, geom, l_margin, r_margin):
        """Autogenerated from C function:
           none guppi_layout_vertical_fill(self, GuppiGeometry geom, double l_margin, double r_margin)"""
        geom = getattr(geom, '_o', geom)
        _ret = _g_plot.guppi_layout_vertical_fill(self._o, geom, l_margin, r_margin)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def aligned_left_edge(self, a, b):
        """Autogenerated from C function:
           none guppi_layout_aligned_left_edge(self, GuppiGeometry a, GuppiGeometry b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_aligned_left_edge(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def aligned_right_edge(self, a, b):
        """Autogenerated from C function:
           none guppi_layout_aligned_right_edge(self, GuppiGeometry a, GuppiGeometry b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_aligned_right_edge(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def aligned_top_edge(self, a, b):
        """Autogenerated from C function:
           none guppi_layout_aligned_top_edge(self, GuppiGeometry a, GuppiGeometry b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_aligned_top_edge(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def aligned_bottom_edge(self, a, b):
        """Autogenerated from C function:
           none guppi_layout_aligned_bottom_edge(self, GuppiGeometry a, GuppiGeometry b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_aligned_bottom_edge(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def horizontally_adjacent(self, left, right, gap):
        """Autogenerated from C function:
           none guppi_layout_horizontally_adjacent(self, GuppiGeometry left, GuppiGeometry right, double gap)"""
        left = getattr(left, '_o', left)
        right = getattr(right, '_o', right)
        _ret = _g_plot.guppi_layout_horizontally_adjacent(self._o, left, right, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def vertically_adjacent(self, top, bot, gap):
        """Autogenerated from C function:
           none guppi_layout_vertically_adjacent(self, GuppiGeometry top, GuppiGeometry bot, double gap)"""
        top = getattr(top, '_o', top)
        bot = getattr(bot, '_o', bot)
        _ret = _g_plot.guppi_layout_vertically_adjacent(self._o, top, bot, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def hbox2(self, left, right, gap):
        """Autogenerated from C function:
           none guppi_layout_hbox2(self, GuppiGeometry left, GuppiGeometry right, double gap)"""
        left = getattr(left, '_o', left)
        right = getattr(right, '_o', right)
        _ret = _g_plot.guppi_layout_hbox2(self._o, left, right, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def hbox3(self, left, center, right, gap):
        """Autogenerated from C function:
           none guppi_layout_hbox3(self, GuppiGeometry left, GuppiGeometry center, GuppiGeometry right, double gap)"""
        left = getattr(left, '_o', left)
        center = getattr(center, '_o', center)
        right = getattr(right, '_o', right)
        _ret = _g_plot.guppi_layout_hbox3(self._o, left, center, right, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def vbox2(self, upper, lower, gap):
        """Autogenerated from C function:
           none guppi_layout_vbox2(self, GuppiGeometry upper, GuppiGeometry lower, double gap)"""
        upper = getattr(upper, '_o', upper)
        lower = getattr(lower, '_o', lower)
        _ret = _g_plot.guppi_layout_vbox2(self._o, upper, lower, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def vbox3(self, upper, center, lower, gap):
        """Autogenerated from C function:
           none guppi_layout_vbox3(self, GuppiGeometry upper, GuppiGeometry center, GuppiGeometry lower, double gap)"""
        upper = getattr(upper, '_o', upper)
        center = getattr(center, '_o', center)
        lower = getattr(lower, '_o', lower)
        _ret = _g_plot.guppi_layout_vbox3(self._o, upper, center, lower, gap)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def width_ratio(self, a, b, ratio):
        """Autogenerated from C function:
           none guppi_layout_width_ratio(self, GuppiGeometry a, GuppiGeometry b, double ratio)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_width_ratio(self._o, a, b, ratio)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def height_ratio(self, a, b, ratio):
        """Autogenerated from C function:
           none guppi_layout_height_ratio(self, GuppiGeometry a, GuppiGeometry b, double ratio)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_height_ratio(self._o, a, b, ratio)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def same_width(self, a, b):
        """Autogenerated from C function:
           none guppi_layout_same_width(self, GuppiGeometry a, GuppiGeometry b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_same_width(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def same_height(self, a, b):
        """Autogenerated from C function:
           none guppi_layout_same_height(self, GuppiGeometry a, GuppiGeometry b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_same_height(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def width_equals_height(self, a, b):
        """Autogenerated from C function:
           none guppi_layout_width_equals_height(self, GuppiGeometry a, GuppiGeometry b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_width_equals_height(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def same_size(self, a, b):
        """Autogenerated from C function:
           none guppi_layout_same_size(self, GuppiGeometry a, GuppiGeometry b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_same_size(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def same_place(self, a, b):
        """Autogenerated from C function:
           none guppi_layout_same_place(self, GuppiGeometry a, GuppiGeometry b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_same_place(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def same_x_center(self, a, b):
        """Autogenerated from C function:
           none guppi_layout_same_x_center(self, GuppiGeometry a, GuppiGeometry b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_same_x_center(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def same_y_center(self, a, b):
        """Autogenerated from C function:
           none guppi_layout_same_y_center(self, GuppiGeometry a, GuppiGeometry b)"""
        a = getattr(a, '_o', a)
        b = getattr(b, '_o', b)
        _ret = _g_plot.guppi_layout_same_y_center(self._o, a, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def calc(self, ):
        """Autogenerated from C function:
           none guppi_layout_calc(self, )"""
        
        _ret = _g_plot.guppi_layout_calc(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiGeometry:    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_plot.guppi_geometry_new()
        
    def left(self, ):
        """Autogenerated from C function:
           double guppi_geometry_left(self, )"""
        
        _ret = _g_plot.guppi_geometry_left(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def right(self, ):
        """Autogenerated from C function:
           double guppi_geometry_right(self, )"""
        
        _ret = _g_plot.guppi_geometry_right(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def top(self, ):
        """Autogenerated from C function:
           double guppi_geometry_top(self, )"""
        
        _ret = _g_plot.guppi_geometry_top(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def bottom(self, ):
        """Autogenerated from C function:
           double guppi_geometry_bottom(self, )"""
        
        _ret = _g_plot.guppi_geometry_bottom(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_position(self, l, r, t, b):
        """Autogenerated from C function:
           none guppi_geometry_set_position(self, double l, double r, double t, double b)"""
        
        _ret = _g_plot.guppi_geometry_set_position(self._o, l, r, t, b)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def natural_width(self, ):
        """Autogenerated from C function:
           double guppi_geometry_natural_width(self, )"""
        
        _ret = _g_plot.guppi_geometry_natural_width(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def natural_height(self, ):
        """Autogenerated from C function:
           double guppi_geometry_natural_height(self, )"""
        
        _ret = _g_plot.guppi_geometry_natural_height(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def calc_natural_size(self, ):
        """Autogenerated from C function:
           none guppi_geometry_calc_natural_size(self, )"""
        
        _ret = _g_plot.guppi_geometry_calc_natural_size(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiRootGroupView(GuppiGroupView):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        raise ValueError, "Class does not have a constructor."
        
    def set_size(self, width, height):
        """Autogenerated from C function:
           none guppi_root_group_view_set_size(self, double width, double height)"""
        
        _ret = _g_plot.guppi_root_group_view_set_size(self._o, width, height)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def width(self, ):
        """Autogenerated from C function:
           double guppi_root_group_view_width(self, )"""
        
        _ret = _g_plot.guppi_root_group_view_width(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def height(self, ):
        """Autogenerated from C function:
           double guppi_root_group_view_height(self, )"""
        
        _ret = _g_plot.guppi_root_group_view_height(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def show_in_window(self, ):
        """Autogenerated from C function:
           none guppi_root_group_view_show_in_window(self, )"""
        
        _ret = _g_plot.guppi_root_group_view_show_in_window(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    

class GuppiRootGroupState(GuppiGroupState):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_plot.guppi_root_group_state_new()
        

class GuppiSeqStyle(GuppiSeq):    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_plot.guppi_seq_style_new()
        
    def get(self, i):
        """Autogenerated from C function:
           GuppiStyle guppi_seq_style_get(self, int i)"""
        
        _ret = _g_plot.guppi_seq_style_get(self._o, i)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set(self, i, sty):
        """Autogenerated from C function:
           none guppi_seq_style_set(self, int i, GuppiStyle sty)"""
        sty = getattr(sty, '_o', sty)
        _ret = _g_plot.guppi_seq_style_set(self._o, i, sty)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def prepend(self, sty):
        """Autogenerated from C function:
           none guppi_seq_style_prepend(self, GuppiStyle sty)"""
        sty = getattr(sty, '_o', sty)
        _ret = _g_plot.guppi_seq_style_prepend(self._o, sty)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def append(self, sty):
        """Autogenerated from C function:
           none guppi_seq_style_append(self, GuppiStyle sty)"""
        sty = getattr(sty, '_o', sty)
        _ret = _g_plot.guppi_seq_style_append(self._o, sty)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def insert(self, i, sty):
        """Autogenerated from C function:
           none guppi_seq_style_insert(self, int i, GuppiStyle sty)"""
        sty = getattr(sty, '_o', sty)
        _ret = _g_plot.guppi_seq_style_insert(self._o, i, sty)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    


def style_new():
    """Autogenerated from C function:
       GuppiStyle guppi_style_new()"""
    _ret = _g_plot.guppi_style_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def style_stock(i, which_collection):
    """Autogenerated from C function:
       GuppiStyle guppi_style_stock(int i, double which_collection)"""
    _ret = _g_plot.guppi_style_stock(i, which_collection)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def seq_style_new():
    """Autogenerated from C function:
       GuppiData guppi_seq_style_new()"""
    _ret = _g_plot.guppi_seq_style_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def color_gradient_new():
    """Autogenerated from C function:
       GuppiColorGradient guppi_color_gradient_new()"""
    _ret = _g_plot.guppi_color_gradient_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def geometry_new():
    """Autogenerated from C function:
       GuppiGeometry guppi_geometry_new()"""
    _ret = _g_plot.guppi_geometry_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def layout_new():
    """Autogenerated from C function:
       GuppiLayout guppi_layout_new()"""
    _ret = _g_plot.guppi_layout_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def element_state_newv(type_name, rest):
    """Autogenerated from C function:
       GuppiElementState guppi_element_state_newv(string type_name, argv rest)"""
    _ret = _g_plot.guppi_element_state_newv(type_name, rest)
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def group_state_new():
    """Autogenerated from C function:
       GuppiElementState guppi_group_state_new()"""
    _ret = _g_plot.guppi_group_state_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret

def root_group_state_new():
    """Autogenerated from C function:
       GuppiElementState guppi_root_group_state_new()"""
    _ret = _g_plot.guppi_root_group_state_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret
import _g_stat

class GuppiSimpleLinreg:    
    def __init__(self,  _obj=None):
        if _obj: self._o = _obj; return
        self._o = _g_stat.guppi_simple_linreg_new()
        
    def set_x_data(self, data):
        """Autogenerated from C function:
           none guppi_simple_linreg_set_x_data(self, GuppiSeqScalar data)"""
        data = getattr(data, '_o', data)
        _ret = _g_stat.guppi_simple_linreg_set_x_data(self._o, data)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_y_data(self, data):
        """Autogenerated from C function:
           none guppi_simple_linreg_set_y_data(self, GuppiSeqScalar data)"""
        data = getattr(data, '_o', data)
        _ret = _g_stat.guppi_simple_linreg_set_y_data(self._o, data)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def set_mask(self, mask):
        """Autogenerated from C function:
           none guppi_simple_linreg_set_mask(self, GuppiSeqBoolean mask)"""
        mask = getattr(mask, '_o', mask)
        _ret = _g_stat.guppi_simple_linreg_set_mask(self._o, mask)
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def slope(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_slope(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_slope(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def intercept(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_intercept(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_intercept(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def R(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_R(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_R(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def R_squared(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_R_squared(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_R_squared(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def residual_sdev(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_residual_sdev(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_residual_sdev(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def slope_serr(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_slope_serr(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_slope_serr(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def intercept_serr(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_intercept_serr(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_intercept_serr(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def slope_t(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_slope_t(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_slope_t(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def intercept_t(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_intercept_t(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_intercept_t(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def slope_p(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_slope_p(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_slope_p(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def intercept_p(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_intercept_p(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_intercept_p(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def F(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_F(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_F(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    
    
    def F_p(self, ):
        """Autogenerated from C function:
           double guppi_simple_linreg_F_p(self, )"""
        
        _ret = _g_stat.guppi_simple_linreg_F_p(self._o, )
        if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
        return _ret
    


def simple_linreg_new():
    """Autogenerated from C function:
       GuppiSimpleLinreg guppi_simple_linreg_new()"""
    _ret = _g_stat.guppi_simple_linreg_new()
    if type(_ret) is _guppi.GuppiObjectType: _ret = _obj2inst(_ret)
    return _ret
_name2cls = {}
_supported = map(lambda x: eval(x), filter(lambda x: x[:5] == 'Guppi', dir()))
_m = None
for _m in _supported:
    _name2cls[_m.__name__] = _m
del _m
_guppi.register_classes(_name2cls)
def _obj2inst(obj):
        objname = _guppi.type_name(obj)
        if _guppi.classes.has_key(objname):
                return _guppi.classes[objname](_obj=obj)
        else: return obj
