# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.7
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_qtgui_swig', [dirname(__file__)])
        except ImportError:
            import _qtgui_swig
            return _qtgui_swig
        if fp is not None:
            try:
                _mod = imp.load_module('_qtgui_swig', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _qtgui_swig = swig_import_helper()
    del swig_import_helper
else:
    import _qtgui_swig
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr



def high_res_timer_now():
    """high_res_timer_now() -> gr::high_res_timer_type"""
    return _qtgui_swig.high_res_timer_now()

def high_res_timer_now_perfmon():
    """high_res_timer_now_perfmon() -> gr::high_res_timer_type"""
    return _qtgui_swig.high_res_timer_now_perfmon()

def high_res_timer_tps():
    """high_res_timer_tps() -> gr::high_res_timer_type"""
    return _qtgui_swig.high_res_timer_tps()

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _qtgui_swig.high_res_timer_epoch()

_qtgui_swig.NUM_GRAPH_NONE_swigconstant(_qtgui_swig)
NUM_GRAPH_NONE = _qtgui_swig.NUM_GRAPH_NONE

_qtgui_swig.NUM_GRAPH_HORIZ_swigconstant(_qtgui_swig)
NUM_GRAPH_HORIZ = _qtgui_swig.NUM_GRAPH_HORIZ

_qtgui_swig.NUM_GRAPH_VERT_swigconstant(_qtgui_swig)
NUM_GRAPH_VERT = _qtgui_swig.NUM_GRAPH_VERT

_qtgui_swig.INTENSITY_COLOR_MAP_TYPE_MULTI_COLOR_swigconstant(_qtgui_swig)
INTENSITY_COLOR_MAP_TYPE_MULTI_COLOR = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_MULTI_COLOR

_qtgui_swig.INTENSITY_COLOR_MAP_TYPE_WHITE_HOT_swigconstant(_qtgui_swig)
INTENSITY_COLOR_MAP_TYPE_WHITE_HOT = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_WHITE_HOT

_qtgui_swig.INTENSITY_COLOR_MAP_TYPE_BLACK_HOT_swigconstant(_qtgui_swig)
INTENSITY_COLOR_MAP_TYPE_BLACK_HOT = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_BLACK_HOT

_qtgui_swig.INTENSITY_COLOR_MAP_TYPE_INCANDESCENT_swigconstant(_qtgui_swig)
INTENSITY_COLOR_MAP_TYPE_INCANDESCENT = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_INCANDESCENT

_qtgui_swig.INTENSITY_COLOR_MAP_TYPE_USER_DEFINED_swigconstant(_qtgui_swig)
INTENSITY_COLOR_MAP_TYPE_USER_DEFINED = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_USER_DEFINED

_qtgui_swig.INTENSITY_COLOR_MAP_TYPE_SUNSET_swigconstant(_qtgui_swig)
INTENSITY_COLOR_MAP_TYPE_SUNSET = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_SUNSET

_qtgui_swig.INTENSITY_COLOR_MAP_TYPE_COOL_swigconstant(_qtgui_swig)
INTENSITY_COLOR_MAP_TYPE_COOL = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_COOL

_qtgui_swig.TRIG_MODE_FREE_swigconstant(_qtgui_swig)
TRIG_MODE_FREE = _qtgui_swig.TRIG_MODE_FREE

_qtgui_swig.TRIG_MODE_AUTO_swigconstant(_qtgui_swig)
TRIG_MODE_AUTO = _qtgui_swig.TRIG_MODE_AUTO

_qtgui_swig.TRIG_MODE_NORM_swigconstant(_qtgui_swig)
TRIG_MODE_NORM = _qtgui_swig.TRIG_MODE_NORM

_qtgui_swig.TRIG_MODE_TAG_swigconstant(_qtgui_swig)
TRIG_MODE_TAG = _qtgui_swig.TRIG_MODE_TAG

_qtgui_swig.TRIG_SLOPE_POS_swigconstant(_qtgui_swig)
TRIG_SLOPE_POS = _qtgui_swig.TRIG_SLOPE_POS

_qtgui_swig.TRIG_SLOPE_NEG_swigconstant(_qtgui_swig)
TRIG_SLOPE_NEG = _qtgui_swig.TRIG_SLOPE_NEG
class sink_c(object):
    """Proxy of C++ gr::qtgui::sink_c class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent=None):
        """make(int fftsize, int wintype, double fc, double bw, std::string const & name, bool plotfreq, bool plotwaterfall, bool plottime, bool plotconst, QWidget * parent=None) -> sink_c_sptr"""
        return _qtgui_swig.sink_c_make(fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(sink_c self)"""
        return _qtgui_swig.sink_c_exec_(self)


    def qwidget(self):
        """qwidget(sink_c self) -> QWidget *"""
        return _qtgui_swig.sink_c_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(sink_c self) -> PyObject *"""
        return _qtgui_swig.sink_c_pyqwidget(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(sink_c self, int const fftsize)"""
        return _qtgui_swig.sink_c_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(sink_c self) -> int"""
        return _qtgui_swig.sink_c_fft_size(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(sink_c self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.sink_c_set_frequency_range(self, centerfreq, bandwidth)


    def set_fft_power_db(self, min, max):
        """set_fft_power_db(sink_c self, double min, double max)"""
        return _qtgui_swig.sink_c_set_fft_power_db(self, min, max)


    def enable_rf_freq(self, en):
        """enable_rf_freq(sink_c self, bool en)"""
        return _qtgui_swig.sink_c_enable_rf_freq(self, en)


    def set_update_time(self, t):
        """set_update_time(sink_c self, double t)"""
        return _qtgui_swig.sink_c_set_update_time(self, t)

    d_qApplication = _swig_property(_qtgui_swig.sink_c_d_qApplication_get, _qtgui_swig.sink_c_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_sink_c
    __del__ = lambda self: None
sink_c_swigregister = _qtgui_swig.sink_c_swigregister
sink_c_swigregister(sink_c)

def sink_c_make(fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent=None):
    """sink_c_make(int fftsize, int wintype, double fc, double bw, std::string const & name, bool plotfreq, bool plotwaterfall, bool plottime, bool plotconst, QWidget * parent=None) -> sink_c_sptr"""
    return _qtgui_swig.sink_c_make(fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent)

class sink_f(object):
    """Proxy of C++ gr::qtgui::sink_f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent=None):
        """make(int fftsize, int wintype, double fc, double bw, std::string const & name, bool plotfreq, bool plotwaterfall, bool plottime, bool plotconst, QWidget * parent=None) -> sink_f_sptr"""
        return _qtgui_swig.sink_f_make(fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(sink_f self)"""
        return _qtgui_swig.sink_f_exec_(self)


    def qwidget(self):
        """qwidget(sink_f self) -> QWidget *"""
        return _qtgui_swig.sink_f_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(sink_f self) -> PyObject *"""
        return _qtgui_swig.sink_f_pyqwidget(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(sink_f self, int const fftsize)"""
        return _qtgui_swig.sink_f_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(sink_f self) -> int"""
        return _qtgui_swig.sink_f_fft_size(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(sink_f self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.sink_f_set_frequency_range(self, centerfreq, bandwidth)


    def set_fft_power_db(self, min, max):
        """set_fft_power_db(sink_f self, double min, double max)"""
        return _qtgui_swig.sink_f_set_fft_power_db(self, min, max)


    def enable_rf_freq(self, en):
        """enable_rf_freq(sink_f self, bool en)"""
        return _qtgui_swig.sink_f_enable_rf_freq(self, en)


    def set_update_time(self, t):
        """set_update_time(sink_f self, double t)"""
        return _qtgui_swig.sink_f_set_update_time(self, t)

    d_qApplication = _swig_property(_qtgui_swig.sink_f_d_qApplication_get, _qtgui_swig.sink_f_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_sink_f
    __del__ = lambda self: None
sink_f_swigregister = _qtgui_swig.sink_f_swigregister
sink_f_swigregister(sink_f)

def sink_f_make(fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent=None):
    """sink_f_make(int fftsize, int wintype, double fc, double bw, std::string const & name, bool plotfreq, bool plotwaterfall, bool plottime, bool plotconst, QWidget * parent=None) -> sink_f_sptr"""
    return _qtgui_swig.sink_f_make(fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent)

class time_sink_c(object):
    """Proxy of C++ gr::qtgui::time_sink_c class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(size, samp_rate, name, nconnections=1, parent=None):
        """make(int size, double samp_rate, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_sink_c_sptr"""
        return _qtgui_swig.time_sink_c_make(size, samp_rate, name, nconnections, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(time_sink_c self)"""
        return _qtgui_swig.time_sink_c_exec_(self)


    def qwidget(self):
        """qwidget(time_sink_c self) -> QWidget *"""
        return _qtgui_swig.time_sink_c_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(time_sink_c self) -> PyObject *"""
        return _qtgui_swig.time_sink_c_pyqwidget(self)


    def set_y_axis(self, min, max):
        """set_y_axis(time_sink_c self, double min, double max)"""
        return _qtgui_swig.time_sink_c_set_y_axis(self, min, max)


    def set_y_label(self, *args, **kwargs):
        """set_y_label(time_sink_c self, std::string const & label, std::string const & unit)"""
        return _qtgui_swig.time_sink_c_set_y_label(self, *args, **kwargs)


    def set_update_time(self, t):
        """set_update_time(time_sink_c self, double t)"""
        return _qtgui_swig.time_sink_c_set_update_time(self, t)


    def set_title(self, title):
        """set_title(time_sink_c self, std::string const & title)"""
        return _qtgui_swig.time_sink_c_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(time_sink_c self, int which, std::string const & label)"""
        return _qtgui_swig.time_sink_c_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(time_sink_c self, int which, std::string const & color)"""
        return _qtgui_swig.time_sink_c_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(time_sink_c self, int which, int width)"""
        return _qtgui_swig.time_sink_c_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(time_sink_c self, int which, int style)"""
        return _qtgui_swig.time_sink_c_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(time_sink_c self, int which, int marker)"""
        return _qtgui_swig.time_sink_c_set_line_marker(self, which, marker)


    def set_nsamps(self, newsize):
        """set_nsamps(time_sink_c self, int const newsize)"""
        return _qtgui_swig.time_sink_c_set_nsamps(self, newsize)


    def set_samp_rate(self, samp_rate):
        """set_samp_rate(time_sink_c self, double const samp_rate)"""
        return _qtgui_swig.time_sink_c_set_samp_rate(self, samp_rate)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(time_sink_c self, int which, double alpha)"""
        return _qtgui_swig.time_sink_c_set_line_alpha(self, which, alpha)


    def set_trigger_mode(self, *args, **kwargs):
        """set_trigger_mode(time_sink_c self, gr::qtgui::trigger_mode mode, gr::qtgui::trigger_slope slope, float level, float delay, int channel, std::string const & tag_key)"""
        return _qtgui_swig.time_sink_c_set_trigger_mode(self, *args, **kwargs)


    def title(self):
        """title(time_sink_c self) -> std::string"""
        return _qtgui_swig.time_sink_c_title(self)


    def line_label(self, which):
        """line_label(time_sink_c self, int which) -> std::string"""
        return _qtgui_swig.time_sink_c_line_label(self, which)


    def line_color(self, which):
        """line_color(time_sink_c self, int which) -> std::string"""
        return _qtgui_swig.time_sink_c_line_color(self, which)


    def line_width(self, which):
        """line_width(time_sink_c self, int which) -> int"""
        return _qtgui_swig.time_sink_c_line_width(self, which)


    def line_style(self, which):
        """line_style(time_sink_c self, int which) -> int"""
        return _qtgui_swig.time_sink_c_line_style(self, which)


    def line_marker(self, which):
        """line_marker(time_sink_c self, int which) -> int"""
        return _qtgui_swig.time_sink_c_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(time_sink_c self, int which) -> double"""
        return _qtgui_swig.time_sink_c_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(time_sink_c self, int width, int height)"""
        return _qtgui_swig.time_sink_c_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(time_sink_c self, bool en=True)"""
        return _qtgui_swig.time_sink_c_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(time_sink_c self, bool en=True)"""
        return _qtgui_swig.time_sink_c_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(time_sink_c self, bool en=True)"""
        return _qtgui_swig.time_sink_c_enable_autoscale(self, en)


    def enable_stem_plot(self, en=True):
        """enable_stem_plot(time_sink_c self, bool en=True)"""
        return _qtgui_swig.time_sink_c_enable_stem_plot(self, en)


    def enable_semilogx(self, en=True):
        """enable_semilogx(time_sink_c self, bool en=True)"""
        return _qtgui_swig.time_sink_c_enable_semilogx(self, en)


    def enable_semilogy(self, en=True):
        """enable_semilogy(time_sink_c self, bool en=True)"""
        return _qtgui_swig.time_sink_c_enable_semilogy(self, en)


    def enable_control_panel(self, en=True):
        """enable_control_panel(time_sink_c self, bool en=True)"""
        return _qtgui_swig.time_sink_c_enable_control_panel(self, en)


    def enable_tags(self, which, en):
        """enable_tags(time_sink_c self, int which, bool en)"""
        return _qtgui_swig.time_sink_c_enable_tags(self, which, en)


    def disable_legend(self):
        """disable_legend(time_sink_c self)"""
        return _qtgui_swig.time_sink_c_disable_legend(self)


    def nsamps(self):
        """nsamps(time_sink_c self) -> int"""
        return _qtgui_swig.time_sink_c_nsamps(self)


    def reset(self):
        """reset(time_sink_c self)"""
        return _qtgui_swig.time_sink_c_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.time_sink_c_d_qApplication_get, _qtgui_swig.time_sink_c_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_time_sink_c
    __del__ = lambda self: None
time_sink_c_swigregister = _qtgui_swig.time_sink_c_swigregister
time_sink_c_swigregister(time_sink_c)

def time_sink_c_make(size, samp_rate, name, nconnections=1, parent=None):
    """time_sink_c_make(int size, double samp_rate, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_sink_c_sptr"""
    return _qtgui_swig.time_sink_c_make(size, samp_rate, name, nconnections, parent)

class time_sink_f(object):
    """Proxy of C++ gr::qtgui::time_sink_f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(size, samp_rate, name, nconnections=1, parent=None):
        """make(int size, double samp_rate, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_sink_f_sptr"""
        return _qtgui_swig.time_sink_f_make(size, samp_rate, name, nconnections, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(time_sink_f self)"""
        return _qtgui_swig.time_sink_f_exec_(self)


    def qwidget(self):
        """qwidget(time_sink_f self) -> QWidget *"""
        return _qtgui_swig.time_sink_f_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(time_sink_f self) -> PyObject *"""
        return _qtgui_swig.time_sink_f_pyqwidget(self)


    def set_y_axis(self, min, max):
        """set_y_axis(time_sink_f self, double min, double max)"""
        return _qtgui_swig.time_sink_f_set_y_axis(self, min, max)


    def set_y_label(self, *args, **kwargs):
        """set_y_label(time_sink_f self, std::string const & label, std::string const & unit)"""
        return _qtgui_swig.time_sink_f_set_y_label(self, *args, **kwargs)


    def set_update_time(self, t):
        """set_update_time(time_sink_f self, double t)"""
        return _qtgui_swig.time_sink_f_set_update_time(self, t)


    def set_title(self, title):
        """set_title(time_sink_f self, std::string const & title)"""
        return _qtgui_swig.time_sink_f_set_title(self, title)


    def set_line_label(self, which, line):
        """set_line_label(time_sink_f self, int which, std::string const & line)"""
        return _qtgui_swig.time_sink_f_set_line_label(self, which, line)


    def set_line_color(self, which, color):
        """set_line_color(time_sink_f self, int which, std::string const & color)"""
        return _qtgui_swig.time_sink_f_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(time_sink_f self, int which, int width)"""
        return _qtgui_swig.time_sink_f_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(time_sink_f self, int which, int style)"""
        return _qtgui_swig.time_sink_f_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(time_sink_f self, int which, int marker)"""
        return _qtgui_swig.time_sink_f_set_line_marker(self, which, marker)


    def set_nsamps(self, newsize):
        """set_nsamps(time_sink_f self, int const newsize)"""
        return _qtgui_swig.time_sink_f_set_nsamps(self, newsize)


    def set_samp_rate(self, samp_rate):
        """set_samp_rate(time_sink_f self, double const samp_rate)"""
        return _qtgui_swig.time_sink_f_set_samp_rate(self, samp_rate)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(time_sink_f self, int which, double alpha)"""
        return _qtgui_swig.time_sink_f_set_line_alpha(self, which, alpha)


    def set_trigger_mode(self, *args, **kwargs):
        """set_trigger_mode(time_sink_f self, gr::qtgui::trigger_mode mode, gr::qtgui::trigger_slope slope, float level, float delay, int channel, std::string const & tag_key)"""
        return _qtgui_swig.time_sink_f_set_trigger_mode(self, *args, **kwargs)


    def title(self):
        """title(time_sink_f self) -> std::string"""
        return _qtgui_swig.time_sink_f_title(self)


    def line_label(self, which):
        """line_label(time_sink_f self, int which) -> std::string"""
        return _qtgui_swig.time_sink_f_line_label(self, which)


    def line_color(self, which):
        """line_color(time_sink_f self, int which) -> std::string"""
        return _qtgui_swig.time_sink_f_line_color(self, which)


    def line_width(self, which):
        """line_width(time_sink_f self, int which) -> int"""
        return _qtgui_swig.time_sink_f_line_width(self, which)


    def line_style(self, which):
        """line_style(time_sink_f self, int which) -> int"""
        return _qtgui_swig.time_sink_f_line_style(self, which)


    def line_marker(self, which):
        """line_marker(time_sink_f self, int which) -> int"""
        return _qtgui_swig.time_sink_f_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(time_sink_f self, int which) -> double"""
        return _qtgui_swig.time_sink_f_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(time_sink_f self, int width, int height)"""
        return _qtgui_swig.time_sink_f_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(time_sink_f self, bool en=True)"""
        return _qtgui_swig.time_sink_f_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(time_sink_f self, bool en=True)"""
        return _qtgui_swig.time_sink_f_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(time_sink_f self, bool en=True)"""
        return _qtgui_swig.time_sink_f_enable_autoscale(self, en)


    def enable_stem_plot(self, en=True):
        """enable_stem_plot(time_sink_f self, bool en=True)"""
        return _qtgui_swig.time_sink_f_enable_stem_plot(self, en)


    def enable_semilogx(self, en=True):
        """enable_semilogx(time_sink_f self, bool en=True)"""
        return _qtgui_swig.time_sink_f_enable_semilogx(self, en)


    def enable_semilogy(self, en=True):
        """enable_semilogy(time_sink_f self, bool en=True)"""
        return _qtgui_swig.time_sink_f_enable_semilogy(self, en)


    def enable_control_panel(self, en=True):
        """enable_control_panel(time_sink_f self, bool en=True)"""
        return _qtgui_swig.time_sink_f_enable_control_panel(self, en)


    def enable_tags(self, which, en):
        """enable_tags(time_sink_f self, int which, bool en)"""
        return _qtgui_swig.time_sink_f_enable_tags(self, which, en)


    def disable_legend(self):
        """disable_legend(time_sink_f self)"""
        return _qtgui_swig.time_sink_f_disable_legend(self)


    def nsamps(self):
        """nsamps(time_sink_f self) -> int"""
        return _qtgui_swig.time_sink_f_nsamps(self)


    def reset(self):
        """reset(time_sink_f self)"""
        return _qtgui_swig.time_sink_f_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.time_sink_f_d_qApplication_get, _qtgui_swig.time_sink_f_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_time_sink_f
    __del__ = lambda self: None
time_sink_f_swigregister = _qtgui_swig.time_sink_f_swigregister
time_sink_f_swigregister(time_sink_f)

def time_sink_f_make(size, samp_rate, name, nconnections=1, parent=None):
    """time_sink_f_make(int size, double samp_rate, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_sink_f_sptr"""
    return _qtgui_swig.time_sink_f_make(size, samp_rate, name, nconnections, parent)

class time_raster_sink_b(object):
    """Proxy of C++ gr::qtgui::time_raster_sink_b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(samp_rate, rows, cols, mult, offset, name, nconnections=1, parent=None):
        """make(double samp_rate, double rows, double cols, pmt_vector_float mult, pmt_vector_float offset, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_raster_sink_b_sptr"""
        return _qtgui_swig.time_raster_sink_b_make(samp_rate, rows, cols, mult, offset, name, nconnections, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(time_raster_sink_b self)"""
        return _qtgui_swig.time_raster_sink_b_exec_(self)


    def qwidget(self):
        """qwidget(time_raster_sink_b self) -> QWidget *"""
        return _qtgui_swig.time_raster_sink_b_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(time_raster_sink_b self) -> PyObject *"""
        return _qtgui_swig.time_raster_sink_b_pyqwidget(self)


    def set_update_time(self, t):
        """set_update_time(time_raster_sink_b self, double t)"""
        return _qtgui_swig.time_raster_sink_b_set_update_time(self, t)


    def set_title(self, title):
        """set_title(time_raster_sink_b self, std::string const & title)"""
        return _qtgui_swig.time_raster_sink_b_set_title(self, title)


    def set_line_label(self, which, lable):
        """set_line_label(time_raster_sink_b self, int which, std::string const & lable)"""
        return _qtgui_swig.time_raster_sink_b_set_line_label(self, which, lable)


    def set_line_color(self, which, color):
        """set_line_color(time_raster_sink_b self, int which, std::string const & color)"""
        return _qtgui_swig.time_raster_sink_b_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(time_raster_sink_b self, int which, int width)"""
        return _qtgui_swig.time_raster_sink_b_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(time_raster_sink_b self, int which, Qt::PenStyle style)"""
        return _qtgui_swig.time_raster_sink_b_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(time_raster_sink_b self, int which, QwtSymbol::Style marker)"""
        return _qtgui_swig.time_raster_sink_b_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(time_raster_sink_b self, int which, double alpha)"""
        return _qtgui_swig.time_raster_sink_b_set_line_alpha(self, which, alpha)


    def set_color_map(self, which, color):
        """set_color_map(time_raster_sink_b self, int which, int const color)"""
        return _qtgui_swig.time_raster_sink_b_set_color_map(self, which, color)


    def title(self):
        """title(time_raster_sink_b self) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_title(self)


    def line_label(self, which):
        """line_label(time_raster_sink_b self, int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_line_label(self, which)


    def line_color(self, which):
        """line_color(time_raster_sink_b self, int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_line_color(self, which)


    def line_width(self, which):
        """line_width(time_raster_sink_b self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_line_width(self, which)


    def line_style(self, which):
        """line_style(time_raster_sink_b self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_line_style(self, which)


    def line_marker(self, which):
        """line_marker(time_raster_sink_b self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(time_raster_sink_b self, int which) -> double"""
        return _qtgui_swig.time_raster_sink_b_line_alpha(self, which)


    def color_map(self, which):
        """color_map(time_raster_sink_b self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_color_map(self, which)


    def set_size(self, width, height):
        """set_size(time_raster_sink_b self, int width, int height)"""
        return _qtgui_swig.time_raster_sink_b_set_size(self, width, height)


    def set_samp_rate(self, samp_rate):
        """set_samp_rate(time_raster_sink_b self, double const samp_rate)"""
        return _qtgui_swig.time_raster_sink_b_set_samp_rate(self, samp_rate)


    def set_num_rows(self, rows):
        """set_num_rows(time_raster_sink_b self, double rows)"""
        return _qtgui_swig.time_raster_sink_b_set_num_rows(self, rows)


    def set_num_cols(self, cols):
        """set_num_cols(time_raster_sink_b self, double cols)"""
        return _qtgui_swig.time_raster_sink_b_set_num_cols(self, cols)


    def num_rows(self):
        """num_rows(time_raster_sink_b self) -> double"""
        return _qtgui_swig.time_raster_sink_b_num_rows(self)


    def num_cols(self):
        """num_cols(time_raster_sink_b self) -> double"""
        return _qtgui_swig.time_raster_sink_b_num_cols(self)


    def set_multiplier(self, mult):
        """set_multiplier(time_raster_sink_b self, pmt_vector_float mult)"""
        return _qtgui_swig.time_raster_sink_b_set_multiplier(self, mult)


    def set_offset(self, offset):
        """set_offset(time_raster_sink_b self, pmt_vector_float offset)"""
        return _qtgui_swig.time_raster_sink_b_set_offset(self, offset)


    def set_intensity_range(self, min, max):
        """set_intensity_range(time_raster_sink_b self, float min, float max)"""
        return _qtgui_swig.time_raster_sink_b_set_intensity_range(self, min, max)


    def enable_menu(self, en):
        """enable_menu(time_raster_sink_b self, bool en)"""
        return _qtgui_swig.time_raster_sink_b_enable_menu(self, en)


    def enable_grid(self, en):
        """enable_grid(time_raster_sink_b self, bool en)"""
        return _qtgui_swig.time_raster_sink_b_enable_grid(self, en)


    def enable_autoscale(self, en):
        """enable_autoscale(time_raster_sink_b self, bool en)"""
        return _qtgui_swig.time_raster_sink_b_enable_autoscale(self, en)


    def reset(self):
        """reset(time_raster_sink_b self)"""
        return _qtgui_swig.time_raster_sink_b_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.time_raster_sink_b_d_qApplication_get, _qtgui_swig.time_raster_sink_b_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_time_raster_sink_b
    __del__ = lambda self: None
time_raster_sink_b_swigregister = _qtgui_swig.time_raster_sink_b_swigregister
time_raster_sink_b_swigregister(time_raster_sink_b)

def time_raster_sink_b_make(samp_rate, rows, cols, mult, offset, name, nconnections=1, parent=None):
    """time_raster_sink_b_make(double samp_rate, double rows, double cols, pmt_vector_float mult, pmt_vector_float offset, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_raster_sink_b_sptr"""
    return _qtgui_swig.time_raster_sink_b_make(samp_rate, rows, cols, mult, offset, name, nconnections, parent)

class time_raster_sink_f(object):
    """Proxy of C++ gr::qtgui::time_raster_sink_f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(samp_rate, rows, cols, mult, offset, name, nconnections=1, parent=None):
        """make(double samp_rate, double rows, double cols, pmt_vector_float mult, pmt_vector_float offset, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_raster_sink_f_sptr"""
        return _qtgui_swig.time_raster_sink_f_make(samp_rate, rows, cols, mult, offset, name, nconnections, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(time_raster_sink_f self)"""
        return _qtgui_swig.time_raster_sink_f_exec_(self)


    def qwidget(self):
        """qwidget(time_raster_sink_f self) -> QWidget *"""
        return _qtgui_swig.time_raster_sink_f_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(time_raster_sink_f self) -> PyObject *"""
        return _qtgui_swig.time_raster_sink_f_pyqwidget(self)


    def set_update_time(self, t):
        """set_update_time(time_raster_sink_f self, double t)"""
        return _qtgui_swig.time_raster_sink_f_set_update_time(self, t)


    def set_title(self, title):
        """set_title(time_raster_sink_f self, std::string const & title)"""
        return _qtgui_swig.time_raster_sink_f_set_title(self, title)


    def set_line_label(self, which, lable):
        """set_line_label(time_raster_sink_f self, int which, std::string const & lable)"""
        return _qtgui_swig.time_raster_sink_f_set_line_label(self, which, lable)


    def set_line_color(self, which, color):
        """set_line_color(time_raster_sink_f self, int which, std::string const & color)"""
        return _qtgui_swig.time_raster_sink_f_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(time_raster_sink_f self, int which, int width)"""
        return _qtgui_swig.time_raster_sink_f_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(time_raster_sink_f self, int which, Qt::PenStyle style)"""
        return _qtgui_swig.time_raster_sink_f_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(time_raster_sink_f self, int which, QwtSymbol::Style marker)"""
        return _qtgui_swig.time_raster_sink_f_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(time_raster_sink_f self, int which, double alpha)"""
        return _qtgui_swig.time_raster_sink_f_set_line_alpha(self, which, alpha)


    def set_color_map(self, which, color):
        """set_color_map(time_raster_sink_f self, int which, int const color)"""
        return _qtgui_swig.time_raster_sink_f_set_color_map(self, which, color)


    def title(self):
        """title(time_raster_sink_f self) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_title(self)


    def line_label(self, which):
        """line_label(time_raster_sink_f self, int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_line_label(self, which)


    def line_color(self, which):
        """line_color(time_raster_sink_f self, int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_line_color(self, which)


    def line_width(self, which):
        """line_width(time_raster_sink_f self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_line_width(self, which)


    def line_style(self, which):
        """line_style(time_raster_sink_f self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_line_style(self, which)


    def line_marker(self, which):
        """line_marker(time_raster_sink_f self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(time_raster_sink_f self, int which) -> double"""
        return _qtgui_swig.time_raster_sink_f_line_alpha(self, which)


    def color_map(self, which):
        """color_map(time_raster_sink_f self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_color_map(self, which)


    def set_size(self, width, height):
        """set_size(time_raster_sink_f self, int width, int height)"""
        return _qtgui_swig.time_raster_sink_f_set_size(self, width, height)


    def set_samp_rate(self, samp_rate):
        """set_samp_rate(time_raster_sink_f self, double const samp_rate)"""
        return _qtgui_swig.time_raster_sink_f_set_samp_rate(self, samp_rate)


    def set_num_rows(self, rows):
        """set_num_rows(time_raster_sink_f self, double rows)"""
        return _qtgui_swig.time_raster_sink_f_set_num_rows(self, rows)


    def set_num_cols(self, cols):
        """set_num_cols(time_raster_sink_f self, double cols)"""
        return _qtgui_swig.time_raster_sink_f_set_num_cols(self, cols)


    def num_rows(self):
        """num_rows(time_raster_sink_f self) -> double"""
        return _qtgui_swig.time_raster_sink_f_num_rows(self)


    def num_cols(self):
        """num_cols(time_raster_sink_f self) -> double"""
        return _qtgui_swig.time_raster_sink_f_num_cols(self)


    def set_multiplier(self, mult):
        """set_multiplier(time_raster_sink_f self, pmt_vector_float mult)"""
        return _qtgui_swig.time_raster_sink_f_set_multiplier(self, mult)


    def set_offset(self, offset):
        """set_offset(time_raster_sink_f self, pmt_vector_float offset)"""
        return _qtgui_swig.time_raster_sink_f_set_offset(self, offset)


    def set_intensity_range(self, min, max):
        """set_intensity_range(time_raster_sink_f self, float min, float max)"""
        return _qtgui_swig.time_raster_sink_f_set_intensity_range(self, min, max)


    def enable_menu(self, en):
        """enable_menu(time_raster_sink_f self, bool en)"""
        return _qtgui_swig.time_raster_sink_f_enable_menu(self, en)


    def enable_grid(self, en):
        """enable_grid(time_raster_sink_f self, bool en)"""
        return _qtgui_swig.time_raster_sink_f_enable_grid(self, en)


    def enable_autoscale(self, en):
        """enable_autoscale(time_raster_sink_f self, bool en)"""
        return _qtgui_swig.time_raster_sink_f_enable_autoscale(self, en)


    def reset(self):
        """reset(time_raster_sink_f self)"""
        return _qtgui_swig.time_raster_sink_f_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.time_raster_sink_f_d_qApplication_get, _qtgui_swig.time_raster_sink_f_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_time_raster_sink_f
    __del__ = lambda self: None
time_raster_sink_f_swigregister = _qtgui_swig.time_raster_sink_f_swigregister
time_raster_sink_f_swigregister(time_raster_sink_f)

def time_raster_sink_f_make(samp_rate, rows, cols, mult, offset, name, nconnections=1, parent=None):
    """time_raster_sink_f_make(double samp_rate, double rows, double cols, pmt_vector_float mult, pmt_vector_float offset, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_raster_sink_f_sptr"""
    return _qtgui_swig.time_raster_sink_f_make(samp_rate, rows, cols, mult, offset, name, nconnections, parent)

class freq_sink_c(object):
    """Proxy of C++ gr::qtgui::freq_sink_c class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(fftsize, wintype, fc, bw, name, nconnections=1, parent=None):
        """make(int fftsize, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> freq_sink_c_sptr"""
        return _qtgui_swig.freq_sink_c_make(fftsize, wintype, fc, bw, name, nconnections, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(freq_sink_c self)"""
        return _qtgui_swig.freq_sink_c_exec_(self)


    def qwidget(self):
        """qwidget(freq_sink_c self) -> QWidget *"""
        return _qtgui_swig.freq_sink_c_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(freq_sink_c self) -> PyObject *"""
        return _qtgui_swig.freq_sink_c_pyqwidget(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(freq_sink_c self, int const fftsize)"""
        return _qtgui_swig.freq_sink_c_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(freq_sink_c self) -> int"""
        return _qtgui_swig.freq_sink_c_fft_size(self)


    def set_fft_average(self, fftavg):
        """set_fft_average(freq_sink_c self, float const fftavg)"""
        return _qtgui_swig.freq_sink_c_set_fft_average(self, fftavg)


    def fft_average(self):
        """fft_average(freq_sink_c self) -> float"""
        return _qtgui_swig.freq_sink_c_fft_average(self)


    def set_fft_window(self, win):
        """set_fft_window(freq_sink_c self, gr::filter::firdes::win_type const win)"""
        return _qtgui_swig.freq_sink_c_set_fft_window(self, win)


    def fft_window(self):
        """fft_window(freq_sink_c self) -> gr::filter::firdes::win_type"""
        return _qtgui_swig.freq_sink_c_fft_window(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(freq_sink_c self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.freq_sink_c_set_frequency_range(self, centerfreq, bandwidth)


    def set_y_axis(self, min, max):
        """set_y_axis(freq_sink_c self, double min, double max)"""
        return _qtgui_swig.freq_sink_c_set_y_axis(self, min, max)


    def set_update_time(self, t):
        """set_update_time(freq_sink_c self, double t)"""
        return _qtgui_swig.freq_sink_c_set_update_time(self, t)


    def set_title(self, title):
        """set_title(freq_sink_c self, std::string const & title)"""
        return _qtgui_swig.freq_sink_c_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(freq_sink_c self, int which, std::string const & label)"""
        return _qtgui_swig.freq_sink_c_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(freq_sink_c self, int which, std::string const & color)"""
        return _qtgui_swig.freq_sink_c_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(freq_sink_c self, int which, int width)"""
        return _qtgui_swig.freq_sink_c_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(freq_sink_c self, int which, int style)"""
        return _qtgui_swig.freq_sink_c_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(freq_sink_c self, int which, int marker)"""
        return _qtgui_swig.freq_sink_c_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(freq_sink_c self, int which, double alpha)"""
        return _qtgui_swig.freq_sink_c_set_line_alpha(self, which, alpha)


    def set_trigger_mode(self, *args, **kwargs):
        """set_trigger_mode(freq_sink_c self, gr::qtgui::trigger_mode mode, float level, int channel, std::string const & tag_key)"""
        return _qtgui_swig.freq_sink_c_set_trigger_mode(self, *args, **kwargs)


    def title(self):
        """title(freq_sink_c self) -> std::string"""
        return _qtgui_swig.freq_sink_c_title(self)


    def line_label(self, which):
        """line_label(freq_sink_c self, int which) -> std::string"""
        return _qtgui_swig.freq_sink_c_line_label(self, which)


    def line_color(self, which):
        """line_color(freq_sink_c self, int which) -> std::string"""
        return _qtgui_swig.freq_sink_c_line_color(self, which)


    def line_width(self, which):
        """line_width(freq_sink_c self, int which) -> int"""
        return _qtgui_swig.freq_sink_c_line_width(self, which)


    def line_style(self, which):
        """line_style(freq_sink_c self, int which) -> int"""
        return _qtgui_swig.freq_sink_c_line_style(self, which)


    def line_marker(self, which):
        """line_marker(freq_sink_c self, int which) -> int"""
        return _qtgui_swig.freq_sink_c_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(freq_sink_c self, int which) -> double"""
        return _qtgui_swig.freq_sink_c_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(freq_sink_c self, int width, int height)"""
        return _qtgui_swig.freq_sink_c_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(freq_sink_c self, bool en=True)"""
        return _qtgui_swig.freq_sink_c_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(freq_sink_c self, bool en=True)"""
        return _qtgui_swig.freq_sink_c_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(freq_sink_c self, bool en=True)"""
        return _qtgui_swig.freq_sink_c_enable_autoscale(self, en)


    def enable_control_panel(self, en=True):
        """enable_control_panel(freq_sink_c self, bool en=True)"""
        return _qtgui_swig.freq_sink_c_enable_control_panel(self, en)


    def enable_max_hold(self, en):
        """enable_max_hold(freq_sink_c self, bool en)"""
        return _qtgui_swig.freq_sink_c_enable_max_hold(self, en)


    def enable_min_hold(self, en):
        """enable_min_hold(freq_sink_c self, bool en)"""
        return _qtgui_swig.freq_sink_c_enable_min_hold(self, en)


    def clear_max_hold(self):
        """clear_max_hold(freq_sink_c self)"""
        return _qtgui_swig.freq_sink_c_clear_max_hold(self)


    def clear_min_hold(self):
        """clear_min_hold(freq_sink_c self)"""
        return _qtgui_swig.freq_sink_c_clear_min_hold(self)


    def disable_legend(self):
        """disable_legend(freq_sink_c self)"""
        return _qtgui_swig.freq_sink_c_disable_legend(self)


    def reset(self):
        """reset(freq_sink_c self)"""
        return _qtgui_swig.freq_sink_c_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.freq_sink_c_d_qApplication_get, _qtgui_swig.freq_sink_c_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_freq_sink_c
    __del__ = lambda self: None
freq_sink_c_swigregister = _qtgui_swig.freq_sink_c_swigregister
freq_sink_c_swigregister(freq_sink_c)

def freq_sink_c_make(fftsize, wintype, fc, bw, name, nconnections=1, parent=None):
    """freq_sink_c_make(int fftsize, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> freq_sink_c_sptr"""
    return _qtgui_swig.freq_sink_c_make(fftsize, wintype, fc, bw, name, nconnections, parent)

class freq_sink_f(object):
    """Proxy of C++ gr::qtgui::freq_sink_f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(fftsize, wintype, fc, bw, name, nconnections=1, parent=None):
        """make(int fftsize, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> freq_sink_f_sptr"""
        return _qtgui_swig.freq_sink_f_make(fftsize, wintype, fc, bw, name, nconnections, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(freq_sink_f self)"""
        return _qtgui_swig.freq_sink_f_exec_(self)


    def qwidget(self):
        """qwidget(freq_sink_f self) -> QWidget *"""
        return _qtgui_swig.freq_sink_f_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(freq_sink_f self) -> PyObject *"""
        return _qtgui_swig.freq_sink_f_pyqwidget(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(freq_sink_f self, int const fftsize)"""
        return _qtgui_swig.freq_sink_f_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(freq_sink_f self) -> int"""
        return _qtgui_swig.freq_sink_f_fft_size(self)


    def set_fft_average(self, fftavg):
        """set_fft_average(freq_sink_f self, float const fftavg)"""
        return _qtgui_swig.freq_sink_f_set_fft_average(self, fftavg)


    def fft_average(self):
        """fft_average(freq_sink_f self) -> float"""
        return _qtgui_swig.freq_sink_f_fft_average(self)


    def set_fft_window(self, win):
        """set_fft_window(freq_sink_f self, gr::filter::firdes::win_type const win)"""
        return _qtgui_swig.freq_sink_f_set_fft_window(self, win)


    def fft_window(self):
        """fft_window(freq_sink_f self) -> gr::filter::firdes::win_type"""
        return _qtgui_swig.freq_sink_f_fft_window(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(freq_sink_f self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.freq_sink_f_set_frequency_range(self, centerfreq, bandwidth)


    def set_y_axis(self, min, max):
        """set_y_axis(freq_sink_f self, double min, double max)"""
        return _qtgui_swig.freq_sink_f_set_y_axis(self, min, max)


    def set_update_time(self, t):
        """set_update_time(freq_sink_f self, double t)"""
        return _qtgui_swig.freq_sink_f_set_update_time(self, t)


    def set_title(self, title):
        """set_title(freq_sink_f self, std::string const & title)"""
        return _qtgui_swig.freq_sink_f_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(freq_sink_f self, int which, std::string const & label)"""
        return _qtgui_swig.freq_sink_f_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(freq_sink_f self, int which, std::string const & color)"""
        return _qtgui_swig.freq_sink_f_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(freq_sink_f self, int which, int width)"""
        return _qtgui_swig.freq_sink_f_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(freq_sink_f self, int which, int style)"""
        return _qtgui_swig.freq_sink_f_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(freq_sink_f self, int which, int marker)"""
        return _qtgui_swig.freq_sink_f_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(freq_sink_f self, int which, double alpha)"""
        return _qtgui_swig.freq_sink_f_set_line_alpha(self, which, alpha)


    def set_plot_pos_half(self, half):
        """set_plot_pos_half(freq_sink_f self, bool half)"""
        return _qtgui_swig.freq_sink_f_set_plot_pos_half(self, half)


    def set_trigger_mode(self, *args, **kwargs):
        """set_trigger_mode(freq_sink_f self, gr::qtgui::trigger_mode mode, float level, int channel, std::string const & tag_key)"""
        return _qtgui_swig.freq_sink_f_set_trigger_mode(self, *args, **kwargs)


    def title(self):
        """title(freq_sink_f self) -> std::string"""
        return _qtgui_swig.freq_sink_f_title(self)


    def line_label(self, which):
        """line_label(freq_sink_f self, int which) -> std::string"""
        return _qtgui_swig.freq_sink_f_line_label(self, which)


    def line_color(self, which):
        """line_color(freq_sink_f self, int which) -> std::string"""
        return _qtgui_swig.freq_sink_f_line_color(self, which)


    def line_width(self, which):
        """line_width(freq_sink_f self, int which) -> int"""
        return _qtgui_swig.freq_sink_f_line_width(self, which)


    def line_style(self, which):
        """line_style(freq_sink_f self, int which) -> int"""
        return _qtgui_swig.freq_sink_f_line_style(self, which)


    def line_marker(self, which):
        """line_marker(freq_sink_f self, int which) -> int"""
        return _qtgui_swig.freq_sink_f_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(freq_sink_f self, int which) -> double"""
        return _qtgui_swig.freq_sink_f_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(freq_sink_f self, int width, int height)"""
        return _qtgui_swig.freq_sink_f_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(freq_sink_f self, bool en=True)"""
        return _qtgui_swig.freq_sink_f_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(freq_sink_f self, bool en=True)"""
        return _qtgui_swig.freq_sink_f_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(freq_sink_f self, bool en=True)"""
        return _qtgui_swig.freq_sink_f_enable_autoscale(self, en)


    def enable_control_panel(self, en=True):
        """enable_control_panel(freq_sink_f self, bool en=True)"""
        return _qtgui_swig.freq_sink_f_enable_control_panel(self, en)


    def enable_max_hold(self, en):
        """enable_max_hold(freq_sink_f self, bool en)"""
        return _qtgui_swig.freq_sink_f_enable_max_hold(self, en)


    def enable_min_hold(self, en):
        """enable_min_hold(freq_sink_f self, bool en)"""
        return _qtgui_swig.freq_sink_f_enable_min_hold(self, en)


    def clear_max_hold(self):
        """clear_max_hold(freq_sink_f self)"""
        return _qtgui_swig.freq_sink_f_clear_max_hold(self)


    def clear_min_hold(self):
        """clear_min_hold(freq_sink_f self)"""
        return _qtgui_swig.freq_sink_f_clear_min_hold(self)


    def disable_legend(self):
        """disable_legend(freq_sink_f self)"""
        return _qtgui_swig.freq_sink_f_disable_legend(self)


    def reset(self):
        """reset(freq_sink_f self)"""
        return _qtgui_swig.freq_sink_f_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.freq_sink_f_d_qApplication_get, _qtgui_swig.freq_sink_f_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_freq_sink_f
    __del__ = lambda self: None
freq_sink_f_swigregister = _qtgui_swig.freq_sink_f_swigregister
freq_sink_f_swigregister(freq_sink_f)

def freq_sink_f_make(fftsize, wintype, fc, bw, name, nconnections=1, parent=None):
    """freq_sink_f_make(int fftsize, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> freq_sink_f_sptr"""
    return _qtgui_swig.freq_sink_f_make(fftsize, wintype, fc, bw, name, nconnections, parent)

class const_sink_c(object):
    """Proxy of C++ gr::qtgui::const_sink_c class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(size, name, nconnections=1, parent=None):
        """make(int size, std::string const & name, int nconnections=1, QWidget * parent=None) -> const_sink_c_sptr"""
        return _qtgui_swig.const_sink_c_make(size, name, nconnections, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(const_sink_c self)"""
        return _qtgui_swig.const_sink_c_exec_(self)


    def qwidget(self):
        """qwidget(const_sink_c self) -> QWidget *"""
        return _qtgui_swig.const_sink_c_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(const_sink_c self) -> PyObject *"""
        return _qtgui_swig.const_sink_c_pyqwidget(self)


    def set_y_axis(self, min, max):
        """set_y_axis(const_sink_c self, double min, double max)"""
        return _qtgui_swig.const_sink_c_set_y_axis(self, min, max)


    def set_x_axis(self, min, max):
        """set_x_axis(const_sink_c self, double min, double max)"""
        return _qtgui_swig.const_sink_c_set_x_axis(self, min, max)


    def set_update_time(self, t):
        """set_update_time(const_sink_c self, double t)"""
        return _qtgui_swig.const_sink_c_set_update_time(self, t)


    def set_title(self, title):
        """set_title(const_sink_c self, std::string const & title)"""
        return _qtgui_swig.const_sink_c_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(const_sink_c self, int which, std::string const & label)"""
        return _qtgui_swig.const_sink_c_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(const_sink_c self, int which, std::string const & color)"""
        return _qtgui_swig.const_sink_c_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(const_sink_c self, int which, int width)"""
        return _qtgui_swig.const_sink_c_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(const_sink_c self, int which, int style)"""
        return _qtgui_swig.const_sink_c_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(const_sink_c self, int which, int marker)"""
        return _qtgui_swig.const_sink_c_set_line_marker(self, which, marker)


    def set_nsamps(self, newsize):
        """set_nsamps(const_sink_c self, int const newsize)"""
        return _qtgui_swig.const_sink_c_set_nsamps(self, newsize)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(const_sink_c self, int which, double alpha)"""
        return _qtgui_swig.const_sink_c_set_line_alpha(self, which, alpha)


    def set_trigger_mode(self, *args, **kwargs):
        """set_trigger_mode(const_sink_c self, gr::qtgui::trigger_mode mode, gr::qtgui::trigger_slope slope, float level, int channel, std::string const & tag_key)"""
        return _qtgui_swig.const_sink_c_set_trigger_mode(self, *args, **kwargs)


    def title(self):
        """title(const_sink_c self) -> std::string"""
        return _qtgui_swig.const_sink_c_title(self)


    def line_label(self, which):
        """line_label(const_sink_c self, int which) -> std::string"""
        return _qtgui_swig.const_sink_c_line_label(self, which)


    def line_color(self, which):
        """line_color(const_sink_c self, int which) -> std::string"""
        return _qtgui_swig.const_sink_c_line_color(self, which)


    def line_width(self, which):
        """line_width(const_sink_c self, int which) -> int"""
        return _qtgui_swig.const_sink_c_line_width(self, which)


    def line_style(self, which):
        """line_style(const_sink_c self, int which) -> int"""
        return _qtgui_swig.const_sink_c_line_style(self, which)


    def line_marker(self, which):
        """line_marker(const_sink_c self, int which) -> int"""
        return _qtgui_swig.const_sink_c_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(const_sink_c self, int which) -> double"""
        return _qtgui_swig.const_sink_c_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(const_sink_c self, int width, int height)"""
        return _qtgui_swig.const_sink_c_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(const_sink_c self, bool en=True)"""
        return _qtgui_swig.const_sink_c_enable_menu(self, en)


    def enable_autoscale(self, en):
        """enable_autoscale(const_sink_c self, bool en)"""
        return _qtgui_swig.const_sink_c_enable_autoscale(self, en)


    def enable_grid(self, en):
        """enable_grid(const_sink_c self, bool en)"""
        return _qtgui_swig.const_sink_c_enable_grid(self, en)


    def disable_legend(self):
        """disable_legend(const_sink_c self)"""
        return _qtgui_swig.const_sink_c_disable_legend(self)


    def nsamps(self):
        """nsamps(const_sink_c self) -> int"""
        return _qtgui_swig.const_sink_c_nsamps(self)


    def reset(self):
        """reset(const_sink_c self)"""
        return _qtgui_swig.const_sink_c_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.const_sink_c_d_qApplication_get, _qtgui_swig.const_sink_c_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_const_sink_c
    __del__ = lambda self: None
const_sink_c_swigregister = _qtgui_swig.const_sink_c_swigregister
const_sink_c_swigregister(const_sink_c)

def const_sink_c_make(size, name, nconnections=1, parent=None):
    """const_sink_c_make(int size, std::string const & name, int nconnections=1, QWidget * parent=None) -> const_sink_c_sptr"""
    return _qtgui_swig.const_sink_c_make(size, name, nconnections, parent)

class waterfall_sink_c(object):
    """Proxy of C++ gr::qtgui::waterfall_sink_c class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(size, wintype, fc, bw, name, nconnections=1, parent=None):
        """make(int size, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> waterfall_sink_c_sptr"""
        return _qtgui_swig.waterfall_sink_c_make(size, wintype, fc, bw, name, nconnections, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(waterfall_sink_c self)"""
        return _qtgui_swig.waterfall_sink_c_exec_(self)


    def qwidget(self):
        """qwidget(waterfall_sink_c self) -> QWidget *"""
        return _qtgui_swig.waterfall_sink_c_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(waterfall_sink_c self) -> PyObject *"""
        return _qtgui_swig.waterfall_sink_c_pyqwidget(self)


    def clear_data(self):
        """clear_data(waterfall_sink_c self)"""
        return _qtgui_swig.waterfall_sink_c_clear_data(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(waterfall_sink_c self, int const fftsize)"""
        return _qtgui_swig.waterfall_sink_c_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(waterfall_sink_c self) -> int"""
        return _qtgui_swig.waterfall_sink_c_fft_size(self)


    def set_time_per_fft(self, t):
        """set_time_per_fft(waterfall_sink_c self, double const t)"""
        return _qtgui_swig.waterfall_sink_c_set_time_per_fft(self, t)


    def set_fft_average(self, fftavg):
        """set_fft_average(waterfall_sink_c self, float const fftavg)"""
        return _qtgui_swig.waterfall_sink_c_set_fft_average(self, fftavg)


    def fft_average(self):
        """fft_average(waterfall_sink_c self) -> float"""
        return _qtgui_swig.waterfall_sink_c_fft_average(self)


    def set_fft_window(self, win):
        """set_fft_window(waterfall_sink_c self, gr::filter::firdes::win_type const win)"""
        return _qtgui_swig.waterfall_sink_c_set_fft_window(self, win)


    def fft_window(self):
        """fft_window(waterfall_sink_c self) -> gr::filter::firdes::win_type"""
        return _qtgui_swig.waterfall_sink_c_fft_window(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(waterfall_sink_c self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.waterfall_sink_c_set_frequency_range(self, centerfreq, bandwidth)


    def set_intensity_range(self, min, max):
        """set_intensity_range(waterfall_sink_c self, double const min, double const max)"""
        return _qtgui_swig.waterfall_sink_c_set_intensity_range(self, min, max)


    def set_update_time(self, t):
        """set_update_time(waterfall_sink_c self, double t)"""
        return _qtgui_swig.waterfall_sink_c_set_update_time(self, t)


    def set_title(self, title):
        """set_title(waterfall_sink_c self, std::string const & title)"""
        return _qtgui_swig.waterfall_sink_c_set_title(self, title)


    def set_time_title(self, title):
        """set_time_title(waterfall_sink_c self, std::string const & title)"""
        return _qtgui_swig.waterfall_sink_c_set_time_title(self, title)


    def set_line_label(self, which, line):
        """set_line_label(waterfall_sink_c self, int which, std::string const & line)"""
        return _qtgui_swig.waterfall_sink_c_set_line_label(self, which, line)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(waterfall_sink_c self, int which, double alpha)"""
        return _qtgui_swig.waterfall_sink_c_set_line_alpha(self, which, alpha)


    def set_color_map(self, which, color):
        """set_color_map(waterfall_sink_c self, int which, int const color)"""
        return _qtgui_swig.waterfall_sink_c_set_color_map(self, which, color)


    def title(self):
        """title(waterfall_sink_c self) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_title(self)


    def line_label(self, which):
        """line_label(waterfall_sink_c self, int which) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_line_label(self, which)


    def line_alpha(self, which):
        """line_alpha(waterfall_sink_c self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_c_line_alpha(self, which)


    def color_map(self, which):
        """color_map(waterfall_sink_c self, int which) -> int"""
        return _qtgui_swig.waterfall_sink_c_color_map(self, which)


    def set_size(self, width, height):
        """set_size(waterfall_sink_c self, int width, int height)"""
        return _qtgui_swig.waterfall_sink_c_set_size(self, width, height)


    def auto_scale(self):
        """auto_scale(waterfall_sink_c self)"""
        return _qtgui_swig.waterfall_sink_c_auto_scale(self)


    def min_intensity(self, which):
        """min_intensity(waterfall_sink_c self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_c_min_intensity(self, which)


    def max_intensity(self, which):
        """max_intensity(waterfall_sink_c self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_c_max_intensity(self, which)


    def enable_menu(self, en=True):
        """enable_menu(waterfall_sink_c self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_c_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(waterfall_sink_c self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_c_enable_grid(self, en)


    def disable_legend(self):
        """disable_legend(waterfall_sink_c self)"""
        return _qtgui_swig.waterfall_sink_c_disable_legend(self)

    d_qApplication = _swig_property(_qtgui_swig.waterfall_sink_c_d_qApplication_get, _qtgui_swig.waterfall_sink_c_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_waterfall_sink_c
    __del__ = lambda self: None
waterfall_sink_c_swigregister = _qtgui_swig.waterfall_sink_c_swigregister
waterfall_sink_c_swigregister(waterfall_sink_c)

def waterfall_sink_c_make(size, wintype, fc, bw, name, nconnections=1, parent=None):
    """waterfall_sink_c_make(int size, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> waterfall_sink_c_sptr"""
    return _qtgui_swig.waterfall_sink_c_make(size, wintype, fc, bw, name, nconnections, parent)

class waterfall_sink_f(object):
    """Proxy of C++ gr::qtgui::waterfall_sink_f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(size, wintype, fc, bw, name, nconnections=1, parent=None):
        """make(int size, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> waterfall_sink_f_sptr"""
        return _qtgui_swig.waterfall_sink_f_make(size, wintype, fc, bw, name, nconnections, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(waterfall_sink_f self)"""
        return _qtgui_swig.waterfall_sink_f_exec_(self)


    def qwidget(self):
        """qwidget(waterfall_sink_f self) -> QWidget *"""
        return _qtgui_swig.waterfall_sink_f_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(waterfall_sink_f self) -> PyObject *"""
        return _qtgui_swig.waterfall_sink_f_pyqwidget(self)


    def clear_data(self):
        """clear_data(waterfall_sink_f self)"""
        return _qtgui_swig.waterfall_sink_f_clear_data(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(waterfall_sink_f self, int const fftsize)"""
        return _qtgui_swig.waterfall_sink_f_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(waterfall_sink_f self) -> int"""
        return _qtgui_swig.waterfall_sink_f_fft_size(self)


    def set_time_per_fft(self, t):
        """set_time_per_fft(waterfall_sink_f self, double const t)"""
        return _qtgui_swig.waterfall_sink_f_set_time_per_fft(self, t)


    def set_fft_average(self, fftavg):
        """set_fft_average(waterfall_sink_f self, float const fftavg)"""
        return _qtgui_swig.waterfall_sink_f_set_fft_average(self, fftavg)


    def fft_average(self):
        """fft_average(waterfall_sink_f self) -> float"""
        return _qtgui_swig.waterfall_sink_f_fft_average(self)


    def set_fft_window(self, win):
        """set_fft_window(waterfall_sink_f self, gr::filter::firdes::win_type const win)"""
        return _qtgui_swig.waterfall_sink_f_set_fft_window(self, win)


    def fft_window(self):
        """fft_window(waterfall_sink_f self) -> gr::filter::firdes::win_type"""
        return _qtgui_swig.waterfall_sink_f_fft_window(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(waterfall_sink_f self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.waterfall_sink_f_set_frequency_range(self, centerfreq, bandwidth)


    def set_intensity_range(self, min, max):
        """set_intensity_range(waterfall_sink_f self, double const min, double const max)"""
        return _qtgui_swig.waterfall_sink_f_set_intensity_range(self, min, max)


    def set_update_time(self, t):
        """set_update_time(waterfall_sink_f self, double t)"""
        return _qtgui_swig.waterfall_sink_f_set_update_time(self, t)


    def set_title(self, title):
        """set_title(waterfall_sink_f self, std::string const & title)"""
        return _qtgui_swig.waterfall_sink_f_set_title(self, title)


    def set_time_title(self, title):
        """set_time_title(waterfall_sink_f self, std::string const & title)"""
        return _qtgui_swig.waterfall_sink_f_set_time_title(self, title)


    def set_line_label(self, which, line):
        """set_line_label(waterfall_sink_f self, int which, std::string const & line)"""
        return _qtgui_swig.waterfall_sink_f_set_line_label(self, which, line)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(waterfall_sink_f self, int which, double alpha)"""
        return _qtgui_swig.waterfall_sink_f_set_line_alpha(self, which, alpha)


    def set_color_map(self, which, color):
        """set_color_map(waterfall_sink_f self, int which, int const color)"""
        return _qtgui_swig.waterfall_sink_f_set_color_map(self, which, color)


    def set_plot_pos_half(self, half):
        """set_plot_pos_half(waterfall_sink_f self, bool half)"""
        return _qtgui_swig.waterfall_sink_f_set_plot_pos_half(self, half)


    def title(self):
        """title(waterfall_sink_f self) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_title(self)


    def line_label(self, which):
        """line_label(waterfall_sink_f self, int which) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_line_label(self, which)


    def line_alpha(self, which):
        """line_alpha(waterfall_sink_f self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_f_line_alpha(self, which)


    def color_map(self, which):
        """color_map(waterfall_sink_f self, int which) -> int"""
        return _qtgui_swig.waterfall_sink_f_color_map(self, which)


    def set_size(self, width, height):
        """set_size(waterfall_sink_f self, int width, int height)"""
        return _qtgui_swig.waterfall_sink_f_set_size(self, width, height)


    def auto_scale(self):
        """auto_scale(waterfall_sink_f self)"""
        return _qtgui_swig.waterfall_sink_f_auto_scale(self)


    def min_intensity(self, which):
        """min_intensity(waterfall_sink_f self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_f_min_intensity(self, which)


    def max_intensity(self, which):
        """max_intensity(waterfall_sink_f self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_f_max_intensity(self, which)


    def enable_menu(self, en=True):
        """enable_menu(waterfall_sink_f self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_f_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(waterfall_sink_f self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_f_enable_grid(self, en)


    def disable_legend(self):
        """disable_legend(waterfall_sink_f self)"""
        return _qtgui_swig.waterfall_sink_f_disable_legend(self)

    d_qApplication = _swig_property(_qtgui_swig.waterfall_sink_f_d_qApplication_get, _qtgui_swig.waterfall_sink_f_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_waterfall_sink_f
    __del__ = lambda self: None
waterfall_sink_f_swigregister = _qtgui_swig.waterfall_sink_f_swigregister
waterfall_sink_f_swigregister(waterfall_sink_f)

def waterfall_sink_f_make(size, wintype, fc, bw, name, nconnections=1, parent=None):
    """waterfall_sink_f_make(int size, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> waterfall_sink_f_sptr"""
    return _qtgui_swig.waterfall_sink_f_make(size, wintype, fc, bw, name, nconnections, parent)

class histogram_sink_f(object):
    """Proxy of C++ gr::qtgui::histogram_sink_f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(size, bins, xmin, xmax, name, nconnections=1, parent=None):
        """make(int size, int bins, double xmin, double xmax, std::string const & name, int nconnections=1, QWidget * parent=None) -> histogram_sink_f_sptr"""
        return _qtgui_swig.histogram_sink_f_make(size, bins, xmin, xmax, name, nconnections, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(histogram_sink_f self)"""
        return _qtgui_swig.histogram_sink_f_exec_(self)


    def qwidget(self):
        """qwidget(histogram_sink_f self) -> QWidget *"""
        return _qtgui_swig.histogram_sink_f_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(histogram_sink_f self) -> PyObject *"""
        return _qtgui_swig.histogram_sink_f_pyqwidget(self)


    def title(self):
        """title(histogram_sink_f self) -> std::string"""
        return _qtgui_swig.histogram_sink_f_title(self)


    def line_label(self, which):
        """line_label(histogram_sink_f self, int which) -> std::string"""
        return _qtgui_swig.histogram_sink_f_line_label(self, which)


    def line_color(self, which):
        """line_color(histogram_sink_f self, int which) -> std::string"""
        return _qtgui_swig.histogram_sink_f_line_color(self, which)


    def line_width(self, which):
        """line_width(histogram_sink_f self, int which) -> int"""
        return _qtgui_swig.histogram_sink_f_line_width(self, which)


    def line_style(self, which):
        """line_style(histogram_sink_f self, int which) -> int"""
        return _qtgui_swig.histogram_sink_f_line_style(self, which)


    def line_marker(self, which):
        """line_marker(histogram_sink_f self, int which) -> int"""
        return _qtgui_swig.histogram_sink_f_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(histogram_sink_f self, int which) -> double"""
        return _qtgui_swig.histogram_sink_f_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(histogram_sink_f self, int width, int height)"""
        return _qtgui_swig.histogram_sink_f_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(histogram_sink_f self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(histogram_sink_f self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(histogram_sink_f self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_enable_autoscale(self, en)


    def enable_semilogx(self, en=True):
        """enable_semilogx(histogram_sink_f self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_enable_semilogx(self, en)


    def enable_semilogy(self, en=True):
        """enable_semilogy(histogram_sink_f self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_enable_semilogy(self, en)


    def enable_accumulate(self, en=True):
        """enable_accumulate(histogram_sink_f self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_enable_accumulate(self, en)


    def autoscalex(self):
        """autoscalex(histogram_sink_f self)"""
        return _qtgui_swig.histogram_sink_f_autoscalex(self)


    def nsamps(self):
        """nsamps(histogram_sink_f self) -> int"""
        return _qtgui_swig.histogram_sink_f_nsamps(self)


    def bins(self):
        """bins(histogram_sink_f self) -> int"""
        return _qtgui_swig.histogram_sink_f_bins(self)


    def reset(self):
        """reset(histogram_sink_f self)"""
        return _qtgui_swig.histogram_sink_f_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.histogram_sink_f_d_qApplication_get, _qtgui_swig.histogram_sink_f_d_qApplication_set)

    def set_y_axis(self, min, max):
        """set_y_axis(histogram_sink_f self, double min, double max)"""
        return _qtgui_swig.histogram_sink_f_set_y_axis(self, min, max)


    def set_x_axis(self, min, max):
        """set_x_axis(histogram_sink_f self, double min, double max)"""
        return _qtgui_swig.histogram_sink_f_set_x_axis(self, min, max)


    def set_update_time(self, t):
        """set_update_time(histogram_sink_f self, double t)"""
        return _qtgui_swig.histogram_sink_f_set_update_time(self, t)


    def set_title(self, title):
        """set_title(histogram_sink_f self, std::string const & title)"""
        return _qtgui_swig.histogram_sink_f_set_title(self, title)


    def set_line_label(self, which, line):
        """set_line_label(histogram_sink_f self, int which, std::string const & line)"""
        return _qtgui_swig.histogram_sink_f_set_line_label(self, which, line)


    def set_line_color(self, which, color):
        """set_line_color(histogram_sink_f self, int which, std::string const & color)"""
        return _qtgui_swig.histogram_sink_f_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(histogram_sink_f self, int which, int width)"""
        return _qtgui_swig.histogram_sink_f_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(histogram_sink_f self, int which, int style)"""
        return _qtgui_swig.histogram_sink_f_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(histogram_sink_f self, int which, int marker)"""
        return _qtgui_swig.histogram_sink_f_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(histogram_sink_f self, int which, double alpha)"""
        return _qtgui_swig.histogram_sink_f_set_line_alpha(self, which, alpha)


    def set_nsamps(self, newsize):
        """set_nsamps(histogram_sink_f self, int const newsize)"""
        return _qtgui_swig.histogram_sink_f_set_nsamps(self, newsize)


    def set_bins(self, bins):
        """set_bins(histogram_sink_f self, int const bins)"""
        return _qtgui_swig.histogram_sink_f_set_bins(self, bins)


    def disable_legend(self):
        """disable_legend(histogram_sink_f self)"""
        return _qtgui_swig.histogram_sink_f_disable_legend(self)

    __swig_destroy__ = _qtgui_swig.delete_histogram_sink_f
    __del__ = lambda self: None
histogram_sink_f_swigregister = _qtgui_swig.histogram_sink_f_swigregister
histogram_sink_f_swigregister(histogram_sink_f)

def histogram_sink_f_make(size, bins, xmin, xmax, name, nconnections=1, parent=None):
    """histogram_sink_f_make(int size, int bins, double xmin, double xmax, std::string const & name, int nconnections=1, QWidget * parent=None) -> histogram_sink_f_sptr"""
    return _qtgui_swig.histogram_sink_f_make(size, bins, xmin, xmax, name, nconnections, parent)

class number_sink(object):
    """Proxy of C++ gr::qtgui::number_sink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(*args, **kwargs):
        """make(size_t itemsize, float average=0, gr::qtgui::graph_t graph_type, int nconnections=1, QWidget * parent=None) -> number_sink_sptr"""
        return _qtgui_swig.number_sink_make(*args, **kwargs)

    make = staticmethod(make)

    def exec_(self):
        """exec_(number_sink self)"""
        return _qtgui_swig.number_sink_exec_(self)


    def qwidget(self):
        """qwidget(number_sink self) -> QWidget *"""
        return _qtgui_swig.number_sink_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(number_sink self) -> PyObject *"""
        return _qtgui_swig.number_sink_pyqwidget(self)


    def set_update_time(self, t):
        """set_update_time(number_sink self, double t)"""
        return _qtgui_swig.number_sink_set_update_time(self, t)


    def set_average(self, avg):
        """set_average(number_sink self, float const avg)"""
        return _qtgui_swig.number_sink_set_average(self, avg)


    def set_graph_type(self, type):
        """set_graph_type(number_sink self, gr::qtgui::graph_t const type)"""
        return _qtgui_swig.number_sink_set_graph_type(self, type)


    def set_color(self, *args):
        """
        set_color(number_sink self, int which, std::string const & min, std::string const & max)
        set_color(number_sink self, int which, int min, int max)
        """
        return _qtgui_swig.number_sink_set_color(self, *args)


    def set_label(self, which, label):
        """set_label(number_sink self, int which, std::string const & label)"""
        return _qtgui_swig.number_sink_set_label(self, which, label)


    def set_min(self, which, min):
        """set_min(number_sink self, int which, float min)"""
        return _qtgui_swig.number_sink_set_min(self, which, min)


    def set_max(self, which, max):
        """set_max(number_sink self, int which, float max)"""
        return _qtgui_swig.number_sink_set_max(self, which, max)


    def set_title(self, title):
        """set_title(number_sink self, std::string const & title)"""
        return _qtgui_swig.number_sink_set_title(self, title)


    def set_unit(self, which, unit):
        """set_unit(number_sink self, int which, std::string const & unit)"""
        return _qtgui_swig.number_sink_set_unit(self, which, unit)


    def set_factor(self, which, factor):
        """set_factor(number_sink self, int which, float factor)"""
        return _qtgui_swig.number_sink_set_factor(self, which, factor)


    def average(self):
        """average(number_sink self) -> float"""
        return _qtgui_swig.number_sink_average(self)


    def graph_type(self):
        """graph_type(number_sink self) -> gr::qtgui::graph_t"""
        return _qtgui_swig.number_sink_graph_type(self)


    def color_min(self, which):
        """color_min(number_sink self, int which) -> std::string"""
        return _qtgui_swig.number_sink_color_min(self, which)


    def color_max(self, which):
        """color_max(number_sink self, int which) -> std::string"""
        return _qtgui_swig.number_sink_color_max(self, which)


    def label(self, which):
        """label(number_sink self, int which) -> std::string"""
        return _qtgui_swig.number_sink_label(self, which)


    def min(self, which):
        """min(number_sink self, int which) -> float"""
        return _qtgui_swig.number_sink_min(self, which)


    def max(self, which):
        """max(number_sink self, int which) -> float"""
        return _qtgui_swig.number_sink_max(self, which)


    def title(self):
        """title(number_sink self) -> std::string"""
        return _qtgui_swig.number_sink_title(self)


    def unit(self, which):
        """unit(number_sink self, int which) -> std::string"""
        return _qtgui_swig.number_sink_unit(self, which)


    def factor(self, which):
        """factor(number_sink self, int which) -> float"""
        return _qtgui_swig.number_sink_factor(self, which)


    def enable_menu(self, en=True):
        """enable_menu(number_sink self, bool en=True)"""
        return _qtgui_swig.number_sink_enable_menu(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(number_sink self, bool en=True)"""
        return _qtgui_swig.number_sink_enable_autoscale(self, en)


    def reset(self):
        """reset(number_sink self)"""
        return _qtgui_swig.number_sink_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.number_sink_d_qApplication_get, _qtgui_swig.number_sink_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_number_sink
    __del__ = lambda self: None
number_sink_swigregister = _qtgui_swig.number_sink_swigregister
number_sink_swigregister(number_sink)

def number_sink_make(*args, **kwargs):
    """number_sink_make(size_t itemsize, float average=0, gr::qtgui::graph_t graph_type, int nconnections=1, QWidget * parent=None) -> number_sink_sptr"""
    return _qtgui_swig.number_sink_make(*args, **kwargs)

class ber_sink_b(object):
    """Proxy of C++ gr::qtgui::ber_sink_b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(*args, **kwargs):
        """make(pmt_vector_float esnos, int curves=1, int berminerrors=100, float berLimit=-7.0, std::vector< std::string,std::allocator< std::string > > curvenames, QWidget * parent=None) -> ber_sink_b_sptr"""
        return _qtgui_swig.ber_sink_b_make(*args, **kwargs)

    make = staticmethod(make)

    def exec_(self):
        """exec_(ber_sink_b self)"""
        return _qtgui_swig.ber_sink_b_exec_(self)


    def pyqwidget(self):
        """pyqwidget(ber_sink_b self) -> PyObject *"""
        return _qtgui_swig.ber_sink_b_pyqwidget(self)


    def set_y_axis(self, min, max):
        """set_y_axis(ber_sink_b self, double min, double max)"""
        return _qtgui_swig.ber_sink_b_set_y_axis(self, min, max)


    def set_x_axis(self, min, max):
        """set_x_axis(ber_sink_b self, double min, double max)"""
        return _qtgui_swig.ber_sink_b_set_x_axis(self, min, max)


    def set_update_time(self, t):
        """set_update_time(ber_sink_b self, double t)"""
        return _qtgui_swig.ber_sink_b_set_update_time(self, t)


    def set_title(self, title):
        """set_title(ber_sink_b self, std::string const & title)"""
        return _qtgui_swig.ber_sink_b_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(ber_sink_b self, int which, std::string const & label)"""
        return _qtgui_swig.ber_sink_b_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(ber_sink_b self, int which, std::string const & color)"""
        return _qtgui_swig.ber_sink_b_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(ber_sink_b self, int which, int width)"""
        return _qtgui_swig.ber_sink_b_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(ber_sink_b self, int which, int style)"""
        return _qtgui_swig.ber_sink_b_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(ber_sink_b self, int which, int marker)"""
        return _qtgui_swig.ber_sink_b_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(ber_sink_b self, int which, double alpha)"""
        return _qtgui_swig.ber_sink_b_set_line_alpha(self, which, alpha)


    def title(self):
        """title(ber_sink_b self) -> std::string"""
        return _qtgui_swig.ber_sink_b_title(self)


    def line_label(self, which):
        """line_label(ber_sink_b self, int which) -> std::string"""
        return _qtgui_swig.ber_sink_b_line_label(self, which)


    def line_color(self, which):
        """line_color(ber_sink_b self, int which) -> std::string"""
        return _qtgui_swig.ber_sink_b_line_color(self, which)


    def line_width(self, which):
        """line_width(ber_sink_b self, int which) -> int"""
        return _qtgui_swig.ber_sink_b_line_width(self, which)


    def line_style(self, which):
        """line_style(ber_sink_b self, int which) -> int"""
        return _qtgui_swig.ber_sink_b_line_style(self, which)


    def line_marker(self, which):
        """line_marker(ber_sink_b self, int which) -> int"""
        return _qtgui_swig.ber_sink_b_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(ber_sink_b self, int which) -> double"""
        return _qtgui_swig.ber_sink_b_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(ber_sink_b self, int width, int height)"""
        return _qtgui_swig.ber_sink_b_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(ber_sink_b self, bool en=True)"""
        return _qtgui_swig.ber_sink_b_enable_menu(self, en)


    def enable_autoscale(self, en):
        """enable_autoscale(ber_sink_b self, bool en)"""
        return _qtgui_swig.ber_sink_b_enable_autoscale(self, en)


    def nsamps(self):
        """nsamps(ber_sink_b self) -> int"""
        return _qtgui_swig.ber_sink_b_nsamps(self)

    d_qApplication = _swig_property(_qtgui_swig.ber_sink_b_d_qApplication_get, _qtgui_swig.ber_sink_b_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_ber_sink_b
    __del__ = lambda self: None
ber_sink_b_swigregister = _qtgui_swig.ber_sink_b_swigregister
ber_sink_b_swigregister(ber_sink_b)

def ber_sink_b_make(*args, **kwargs):
    """ber_sink_b_make(pmt_vector_float esnos, int curves=1, int berminerrors=100, float berLimit=-7.0, std::vector< std::string,std::allocator< std::string > > curvenames, QWidget * parent=None) -> ber_sink_b_sptr"""
    return _qtgui_swig.ber_sink_b_make(*args, **kwargs)

class vector_sink_f(object):
    """Proxy of C++ gr::qtgui::vector_sink_f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(vlen, x_start, x_step, x_axis_label, y_axis_label, name, nconnections=1, parent=None):
        """make(int vlen, double x_start, double x_step, std::string const & x_axis_label, std::string const & y_axis_label, std::string const & name, int nconnections=1, QWidget * parent=None) -> vector_sink_f_sptr"""
        return _qtgui_swig.vector_sink_f_make(vlen, x_start, x_step, x_axis_label, y_axis_label, name, nconnections, parent)

    make = staticmethod(make)

    def exec_(self):
        """exec_(vector_sink_f self)"""
        return _qtgui_swig.vector_sink_f_exec_(self)


    def qwidget(self):
        """qwidget(vector_sink_f self) -> QWidget *"""
        return _qtgui_swig.vector_sink_f_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(vector_sink_f self) -> PyObject *"""
        return _qtgui_swig.vector_sink_f_pyqwidget(self)


    def vlen(self):
        """vlen(vector_sink_f self) -> int"""
        return _qtgui_swig.vector_sink_f_vlen(self)


    def set_vec_average(self, avg):
        """set_vec_average(vector_sink_f self, float const avg)"""
        return _qtgui_swig.vector_sink_f_set_vec_average(self, avg)


    def vec_average(self):
        """vec_average(vector_sink_f self) -> float"""
        return _qtgui_swig.vector_sink_f_vec_average(self)


    def set_x_axis(self, start, step):
        """set_x_axis(vector_sink_f self, double const start, double const step)"""
        return _qtgui_swig.vector_sink_f_set_x_axis(self, start, step)


    def set_y_axis(self, min, max):
        """set_y_axis(vector_sink_f self, double min, double max)"""
        return _qtgui_swig.vector_sink_f_set_y_axis(self, min, max)


    def set_ref_level(self, ref_level):
        """set_ref_level(vector_sink_f self, double ref_level)"""
        return _qtgui_swig.vector_sink_f_set_ref_level(self, ref_level)


    def set_x_axis_label(self, label):
        """set_x_axis_label(vector_sink_f self, std::string const & label)"""
        return _qtgui_swig.vector_sink_f_set_x_axis_label(self, label)


    def set_y_axis_label(self, label):
        """set_y_axis_label(vector_sink_f self, std::string const & label)"""
        return _qtgui_swig.vector_sink_f_set_y_axis_label(self, label)


    def set_x_axis_units(self, units):
        """set_x_axis_units(vector_sink_f self, std::string const & units)"""
        return _qtgui_swig.vector_sink_f_set_x_axis_units(self, units)


    def set_y_axis_units(self, units):
        """set_y_axis_units(vector_sink_f self, std::string const & units)"""
        return _qtgui_swig.vector_sink_f_set_y_axis_units(self, units)


    def set_update_time(self, t):
        """set_update_time(vector_sink_f self, double t)"""
        return _qtgui_swig.vector_sink_f_set_update_time(self, t)


    def set_title(self, title):
        """set_title(vector_sink_f self, std::string const & title)"""
        return _qtgui_swig.vector_sink_f_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(vector_sink_f self, int which, std::string const & label)"""
        return _qtgui_swig.vector_sink_f_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(vector_sink_f self, int which, std::string const & color)"""
        return _qtgui_swig.vector_sink_f_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(vector_sink_f self, int which, int width)"""
        return _qtgui_swig.vector_sink_f_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(vector_sink_f self, int which, int style)"""
        return _qtgui_swig.vector_sink_f_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(vector_sink_f self, int which, int marker)"""
        return _qtgui_swig.vector_sink_f_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(vector_sink_f self, int which, double alpha)"""
        return _qtgui_swig.vector_sink_f_set_line_alpha(self, which, alpha)


    def title(self):
        """title(vector_sink_f self) -> std::string"""
        return _qtgui_swig.vector_sink_f_title(self)


    def line_label(self, which):
        """line_label(vector_sink_f self, int which) -> std::string"""
        return _qtgui_swig.vector_sink_f_line_label(self, which)


    def line_color(self, which):
        """line_color(vector_sink_f self, int which) -> std::string"""
        return _qtgui_swig.vector_sink_f_line_color(self, which)


    def line_width(self, which):
        """line_width(vector_sink_f self, int which) -> int"""
        return _qtgui_swig.vector_sink_f_line_width(self, which)


    def line_style(self, which):
        """line_style(vector_sink_f self, int which) -> int"""
        return _qtgui_swig.vector_sink_f_line_style(self, which)


    def line_marker(self, which):
        """line_marker(vector_sink_f self, int which) -> int"""
        return _qtgui_swig.vector_sink_f_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(vector_sink_f self, int which) -> double"""
        return _qtgui_swig.vector_sink_f_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(vector_sink_f self, int width, int height)"""
        return _qtgui_swig.vector_sink_f_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(vector_sink_f self, bool en=True)"""
        return _qtgui_swig.vector_sink_f_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(vector_sink_f self, bool en=True)"""
        return _qtgui_swig.vector_sink_f_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(vector_sink_f self, bool en=True)"""
        return _qtgui_swig.vector_sink_f_enable_autoscale(self, en)


    def clear_max_hold(self):
        """clear_max_hold(vector_sink_f self)"""
        return _qtgui_swig.vector_sink_f_clear_max_hold(self)


    def clear_min_hold(self):
        """clear_min_hold(vector_sink_f self)"""
        return _qtgui_swig.vector_sink_f_clear_min_hold(self)


    def reset(self):
        """reset(vector_sink_f self)"""
        return _qtgui_swig.vector_sink_f_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.vector_sink_f_d_qApplication_get, _qtgui_swig.vector_sink_f_d_qApplication_set)
    __swig_destroy__ = _qtgui_swig.delete_vector_sink_f
    __del__ = lambda self: None
vector_sink_f_swigregister = _qtgui_swig.vector_sink_f_swigregister
vector_sink_f_swigregister(vector_sink_f)

def vector_sink_f_make(vlen, x_start, x_step, x_axis_label, y_axis_label, name, nconnections=1, parent=None):
    """vector_sink_f_make(int vlen, double x_start, double x_step, std::string const & x_axis_label, std::string const & y_axis_label, std::string const & name, int nconnections=1, QWidget * parent=None) -> vector_sink_f_sptr"""
    return _qtgui_swig.vector_sink_f_make(vlen, x_start, x_step, x_axis_label, y_axis_label, name, nconnections, parent)

class sink_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::sink_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::sink_c)> self) -> sink_c_sptr
        __init__(boost::shared_ptr<(gr::qtgui::sink_c)> self, sink_c p) -> sink_c_sptr
        """
        this = _qtgui_swig.new_sink_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(sink_c_sptr self) -> sink_c"""
        return _qtgui_swig.sink_c_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_sink_c_sptr
    __del__ = lambda self: None

    def make(self, fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent=None):
        """make(sink_c_sptr self, int fftsize, int wintype, double fc, double bw, std::string const & name, bool plotfreq, bool plotwaterfall, bool plottime, bool plotconst, QWidget * parent=None) -> sink_c_sptr"""
        return _qtgui_swig.sink_c_sptr_make(self, fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent)


    def exec_(self):
        """exec_(sink_c_sptr self)"""
        return _qtgui_swig.sink_c_sptr_exec_(self)


    def qwidget(self):
        """qwidget(sink_c_sptr self) -> QWidget *"""
        return _qtgui_swig.sink_c_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(sink_c_sptr self) -> PyObject *"""
        return _qtgui_swig.sink_c_sptr_pyqwidget(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(sink_c_sptr self, int const fftsize)"""
        return _qtgui_swig.sink_c_sptr_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(sink_c_sptr self) -> int"""
        return _qtgui_swig.sink_c_sptr_fft_size(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(sink_c_sptr self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.sink_c_sptr_set_frequency_range(self, centerfreq, bandwidth)


    def set_fft_power_db(self, min, max):
        """set_fft_power_db(sink_c_sptr self, double min, double max)"""
        return _qtgui_swig.sink_c_sptr_set_fft_power_db(self, min, max)


    def enable_rf_freq(self, en):
        """enable_rf_freq(sink_c_sptr self, bool en)"""
        return _qtgui_swig.sink_c_sptr_enable_rf_freq(self, en)


    def set_update_time(self, t):
        """set_update_time(sink_c_sptr self, double t)"""
        return _qtgui_swig.sink_c_sptr_set_update_time(self, t)

    d_qApplication = _swig_property(_qtgui_swig.sink_c_sptr_d_qApplication_get, _qtgui_swig.sink_c_sptr_d_qApplication_set)

    def history(self):
        """history(sink_c_sptr self) -> unsigned int"""
        return _qtgui_swig.sink_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sink_c_sptr self, int which, int delay)
        declare_sample_delay(sink_c_sptr self, unsigned int delay)
        """
        return _qtgui_swig.sink_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sink_c_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.sink_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sink_c_sptr self) -> int"""
        return _qtgui_swig.sink_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sink_c_sptr self) -> double"""
        return _qtgui_swig.sink_c_sptr_relative_rate(self)


    def start(self):
        """start(sink_c_sptr self) -> bool"""
        return _qtgui_swig.sink_c_sptr_start(self)


    def stop(self):
        """stop(sink_c_sptr self) -> bool"""
        return _qtgui_swig.sink_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sink_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.sink_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sink_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.sink_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sink_c_sptr self) -> int"""
        return _qtgui_swig.sink_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sink_c_sptr self, int m)"""
        return _qtgui_swig.sink_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sink_c_sptr self)"""
        return _qtgui_swig.sink_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sink_c_sptr self) -> bool"""
        return _qtgui_swig.sink_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sink_c_sptr self, int m)"""
        return _qtgui_swig.sink_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sink_c_sptr self) -> int"""
        return _qtgui_swig.sink_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sink_c_sptr self, int i) -> long"""
        return _qtgui_swig.sink_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sink_c_sptr self, long max_output_buffer)
        set_max_output_buffer(sink_c_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.sink_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sink_c_sptr self, int i) -> long"""
        return _qtgui_swig.sink_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sink_c_sptr self, long min_output_buffer)
        set_min_output_buffer(sink_c_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.sink_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sink_c_sptr self, int which) -> float
        pc_input_buffers_full(sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sink_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sink_c_sptr self, int which) -> float
        pc_input_buffers_full_var(sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sink_c_sptr self, int which) -> float
        pc_output_buffers_full(sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sink_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sink_c_sptr self, int which) -> float
        pc_output_buffers_full_var(sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sink_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.sink_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sink_c_sptr self)"""
        return _qtgui_swig.sink_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sink_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.sink_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sink_c_sptr self) -> int"""
        return _qtgui_swig.sink_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sink_c_sptr self) -> int"""
        return _qtgui_swig.sink_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sink_c_sptr self, int priority) -> int"""
        return _qtgui_swig.sink_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sink_c_sptr self) -> std::string"""
        return _qtgui_swig.sink_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sink_c_sptr self) -> std::string"""
        return _qtgui_swig.sink_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.sink_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.sink_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sink_c_sptr self) -> long"""
        return _qtgui_swig.sink_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sink_c_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.sink_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sink_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.sink_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sink_c_sptr self) -> std::string"""
        return _qtgui_swig.sink_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sink_c_sptr self, std::string name)"""
        return _qtgui_swig.sink_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sink_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.sink_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sink_c_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.sink_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sink_c_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.sink_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sink_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.sink_c_sptr_message_subscribers(self, which_port)

sink_c_sptr_swigregister = _qtgui_swig.sink_c_sptr_swigregister
sink_c_sptr_swigregister(sink_c_sptr)


sink_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
sink_c = sink_c.make;

class sink_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::sink_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::sink_f)> self) -> sink_f_sptr
        __init__(boost::shared_ptr<(gr::qtgui::sink_f)> self, sink_f p) -> sink_f_sptr
        """
        this = _qtgui_swig.new_sink_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(sink_f_sptr self) -> sink_f"""
        return _qtgui_swig.sink_f_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_sink_f_sptr
    __del__ = lambda self: None

    def make(self, fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent=None):
        """make(sink_f_sptr self, int fftsize, int wintype, double fc, double bw, std::string const & name, bool plotfreq, bool plotwaterfall, bool plottime, bool plotconst, QWidget * parent=None) -> sink_f_sptr"""
        return _qtgui_swig.sink_f_sptr_make(self, fftsize, wintype, fc, bw, name, plotfreq, plotwaterfall, plottime, plotconst, parent)


    def exec_(self):
        """exec_(sink_f_sptr self)"""
        return _qtgui_swig.sink_f_sptr_exec_(self)


    def qwidget(self):
        """qwidget(sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.sink_f_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.sink_f_sptr_pyqwidget(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(sink_f_sptr self, int const fftsize)"""
        return _qtgui_swig.sink_f_sptr_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(sink_f_sptr self) -> int"""
        return _qtgui_swig.sink_f_sptr_fft_size(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(sink_f_sptr self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.sink_f_sptr_set_frequency_range(self, centerfreq, bandwidth)


    def set_fft_power_db(self, min, max):
        """set_fft_power_db(sink_f_sptr self, double min, double max)"""
        return _qtgui_swig.sink_f_sptr_set_fft_power_db(self, min, max)


    def enable_rf_freq(self, en):
        """enable_rf_freq(sink_f_sptr self, bool en)"""
        return _qtgui_swig.sink_f_sptr_enable_rf_freq(self, en)


    def set_update_time(self, t):
        """set_update_time(sink_f_sptr self, double t)"""
        return _qtgui_swig.sink_f_sptr_set_update_time(self, t)

    d_qApplication = _swig_property(_qtgui_swig.sink_f_sptr_d_qApplication_get, _qtgui_swig.sink_f_sptr_d_qApplication_set)

    def history(self):
        """history(sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.sink_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sink_f_sptr self, int which, int delay)
        declare_sample_delay(sink_f_sptr self, unsigned int delay)
        """
        return _qtgui_swig.sink_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.sink_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sink_f_sptr self) -> int"""
        return _qtgui_swig.sink_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sink_f_sptr self) -> double"""
        return _qtgui_swig.sink_f_sptr_relative_rate(self)


    def start(self):
        """start(sink_f_sptr self) -> bool"""
        return _qtgui_swig.sink_f_sptr_start(self)


    def stop(self):
        """stop(sink_f_sptr self) -> bool"""
        return _qtgui_swig.sink_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sink_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.sink_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.sink_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sink_f_sptr self) -> int"""
        return _qtgui_swig.sink_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sink_f_sptr self, int m)"""
        return _qtgui_swig.sink_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sink_f_sptr self)"""
        return _qtgui_swig.sink_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sink_f_sptr self) -> bool"""
        return _qtgui_swig.sink_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sink_f_sptr self, int m)"""
        return _qtgui_swig.sink_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sink_f_sptr self) -> int"""
        return _qtgui_swig.sink_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.sink_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sink_f_sptr self, long max_output_buffer)
        set_max_output_buffer(sink_f_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.sink_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.sink_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sink_f_sptr self, long min_output_buffer)
        set_min_output_buffer(sink_f_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.sink_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sink_f_sptr self, int which) -> float
        pc_input_buffers_full(sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sink_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sink_f_sptr self, int which) -> float
        pc_input_buffers_full_var(sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sink_f_sptr self, int which) -> float
        pc_output_buffers_full(sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sink_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sink_f_sptr self, int which) -> float
        pc_output_buffers_full_var(sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.sink_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sink_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.sink_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sink_f_sptr self)"""
        return _qtgui_swig.sink_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sink_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.sink_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sink_f_sptr self) -> int"""
        return _qtgui_swig.sink_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sink_f_sptr self) -> int"""
        return _qtgui_swig.sink_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sink_f_sptr self, int priority) -> int"""
        return _qtgui_swig.sink_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sink_f_sptr self) -> std::string"""
        return _qtgui_swig.sink_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sink_f_sptr self) -> std::string"""
        return _qtgui_swig.sink_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.sink_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.sink_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sink_f_sptr self) -> long"""
        return _qtgui_swig.sink_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sink_f_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.sink_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sink_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.sink_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sink_f_sptr self) -> std::string"""
        return _qtgui_swig.sink_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sink_f_sptr self, std::string name)"""
        return _qtgui_swig.sink_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sink_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.sink_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.sink_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.sink_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sink_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.sink_f_sptr_message_subscribers(self, which_port)

sink_f_sptr_swigregister = _qtgui_swig.sink_f_sptr_swigregister
sink_f_sptr_swigregister(sink_f_sptr)


sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
sink_f = sink_f.make;

class time_sink_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::time_sink_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::time_sink_c)> self) -> time_sink_c_sptr
        __init__(boost::shared_ptr<(gr::qtgui::time_sink_c)> self, time_sink_c p) -> time_sink_c_sptr
        """
        this = _qtgui_swig.new_time_sink_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(time_sink_c_sptr self) -> time_sink_c"""
        return _qtgui_swig.time_sink_c_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_time_sink_c_sptr
    __del__ = lambda self: None

    def make(self, size, samp_rate, name, nconnections=1, parent=None):
        """make(time_sink_c_sptr self, int size, double samp_rate, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_sink_c_sptr"""
        return _qtgui_swig.time_sink_c_sptr_make(self, size, samp_rate, name, nconnections, parent)


    def exec_(self):
        """exec_(time_sink_c_sptr self)"""
        return _qtgui_swig.time_sink_c_sptr_exec_(self)


    def qwidget(self):
        """qwidget(time_sink_c_sptr self) -> QWidget *"""
        return _qtgui_swig.time_sink_c_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(time_sink_c_sptr self) -> PyObject *"""
        return _qtgui_swig.time_sink_c_sptr_pyqwidget(self)


    def set_y_axis(self, min, max):
        """set_y_axis(time_sink_c_sptr self, double min, double max)"""
        return _qtgui_swig.time_sink_c_sptr_set_y_axis(self, min, max)


    def set_y_label(self, *args, **kwargs):
        """set_y_label(time_sink_c_sptr self, std::string const & label, std::string const & unit)"""
        return _qtgui_swig.time_sink_c_sptr_set_y_label(self, *args, **kwargs)


    def set_update_time(self, t):
        """set_update_time(time_sink_c_sptr self, double t)"""
        return _qtgui_swig.time_sink_c_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(time_sink_c_sptr self, std::string const & title)"""
        return _qtgui_swig.time_sink_c_sptr_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(time_sink_c_sptr self, int which, std::string const & label)"""
        return _qtgui_swig.time_sink_c_sptr_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(time_sink_c_sptr self, int which, std::string const & color)"""
        return _qtgui_swig.time_sink_c_sptr_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(time_sink_c_sptr self, int which, int width)"""
        return _qtgui_swig.time_sink_c_sptr_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(time_sink_c_sptr self, int which, int style)"""
        return _qtgui_swig.time_sink_c_sptr_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(time_sink_c_sptr self, int which, int marker)"""
        return _qtgui_swig.time_sink_c_sptr_set_line_marker(self, which, marker)


    def set_nsamps(self, newsize):
        """set_nsamps(time_sink_c_sptr self, int const newsize)"""
        return _qtgui_swig.time_sink_c_sptr_set_nsamps(self, newsize)


    def set_samp_rate(self, samp_rate):
        """set_samp_rate(time_sink_c_sptr self, double const samp_rate)"""
        return _qtgui_swig.time_sink_c_sptr_set_samp_rate(self, samp_rate)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(time_sink_c_sptr self, int which, double alpha)"""
        return _qtgui_swig.time_sink_c_sptr_set_line_alpha(self, which, alpha)


    def set_trigger_mode(self, *args, **kwargs):
        """set_trigger_mode(time_sink_c_sptr self, gr::qtgui::trigger_mode mode, gr::qtgui::trigger_slope slope, float level, float delay, int channel, std::string const & tag_key)"""
        return _qtgui_swig.time_sink_c_sptr_set_trigger_mode(self, *args, **kwargs)


    def title(self):
        """title(time_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_c_sptr_title(self)


    def line_label(self, which):
        """line_label(time_sink_c_sptr self, int which) -> std::string"""
        return _qtgui_swig.time_sink_c_sptr_line_label(self, which)


    def line_color(self, which):
        """line_color(time_sink_c_sptr self, int which) -> std::string"""
        return _qtgui_swig.time_sink_c_sptr_line_color(self, which)


    def line_width(self, which):
        """line_width(time_sink_c_sptr self, int which) -> int"""
        return _qtgui_swig.time_sink_c_sptr_line_width(self, which)


    def line_style(self, which):
        """line_style(time_sink_c_sptr self, int which) -> int"""
        return _qtgui_swig.time_sink_c_sptr_line_style(self, which)


    def line_marker(self, which):
        """line_marker(time_sink_c_sptr self, int which) -> int"""
        return _qtgui_swig.time_sink_c_sptr_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(time_sink_c_sptr self, int which) -> double"""
        return _qtgui_swig.time_sink_c_sptr_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(time_sink_c_sptr self, int width, int height)"""
        return _qtgui_swig.time_sink_c_sptr_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(time_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_c_sptr_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(time_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_c_sptr_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(time_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_c_sptr_enable_autoscale(self, en)


    def enable_stem_plot(self, en=True):
        """enable_stem_plot(time_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_c_sptr_enable_stem_plot(self, en)


    def enable_semilogx(self, en=True):
        """enable_semilogx(time_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_c_sptr_enable_semilogx(self, en)


    def enable_semilogy(self, en=True):
        """enable_semilogy(time_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_c_sptr_enable_semilogy(self, en)


    def enable_control_panel(self, en=True):
        """enable_control_panel(time_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_c_sptr_enable_control_panel(self, en)


    def enable_tags(self, which, en):
        """enable_tags(time_sink_c_sptr self, int which, bool en)"""
        return _qtgui_swig.time_sink_c_sptr_enable_tags(self, which, en)


    def disable_legend(self):
        """disable_legend(time_sink_c_sptr self)"""
        return _qtgui_swig.time_sink_c_sptr_disable_legend(self)


    def nsamps(self):
        """nsamps(time_sink_c_sptr self) -> int"""
        return _qtgui_swig.time_sink_c_sptr_nsamps(self)


    def reset(self):
        """reset(time_sink_c_sptr self)"""
        return _qtgui_swig.time_sink_c_sptr_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.time_sink_c_sptr_d_qApplication_get, _qtgui_swig.time_sink_c_sptr_d_qApplication_set)

    def history(self):
        """history(time_sink_c_sptr self) -> unsigned int"""
        return _qtgui_swig.time_sink_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(time_sink_c_sptr self, int which, int delay)
        declare_sample_delay(time_sink_c_sptr self, unsigned int delay)
        """
        return _qtgui_swig.time_sink_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(time_sink_c_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.time_sink_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(time_sink_c_sptr self) -> int"""
        return _qtgui_swig.time_sink_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(time_sink_c_sptr self) -> double"""
        return _qtgui_swig.time_sink_c_sptr_relative_rate(self)


    def start(self):
        """start(time_sink_c_sptr self) -> bool"""
        return _qtgui_swig.time_sink_c_sptr_start(self)


    def stop(self):
        """stop(time_sink_c_sptr self) -> bool"""
        return _qtgui_swig.time_sink_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(time_sink_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.time_sink_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(time_sink_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.time_sink_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(time_sink_c_sptr self) -> int"""
        return _qtgui_swig.time_sink_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(time_sink_c_sptr self, int m)"""
        return _qtgui_swig.time_sink_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(time_sink_c_sptr self)"""
        return _qtgui_swig.time_sink_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(time_sink_c_sptr self) -> bool"""
        return _qtgui_swig.time_sink_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(time_sink_c_sptr self, int m)"""
        return _qtgui_swig.time_sink_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(time_sink_c_sptr self) -> int"""
        return _qtgui_swig.time_sink_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(time_sink_c_sptr self, int i) -> long"""
        return _qtgui_swig.time_sink_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(time_sink_c_sptr self, long max_output_buffer)
        set_max_output_buffer(time_sink_c_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.time_sink_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(time_sink_c_sptr self, int i) -> long"""
        return _qtgui_swig.time_sink_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(time_sink_c_sptr self, long min_output_buffer)
        set_min_output_buffer(time_sink_c_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.time_sink_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(time_sink_c_sptr self, int which) -> float
        pc_input_buffers_full(time_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(time_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(time_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(time_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_var(time_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(time_sink_c_sptr self, int which) -> float
        pc_output_buffers_full(time_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(time_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(time_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(time_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_var(time_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(time_sink_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.time_sink_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(time_sink_c_sptr self)"""
        return _qtgui_swig.time_sink_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(time_sink_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.time_sink_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(time_sink_c_sptr self) -> int"""
        return _qtgui_swig.time_sink_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(time_sink_c_sptr self) -> int"""
        return _qtgui_swig.time_sink_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(time_sink_c_sptr self, int priority) -> int"""
        return _qtgui_swig.time_sink_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(time_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(time_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(time_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_sink_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(time_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_sink_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(time_sink_c_sptr self) -> long"""
        return _qtgui_swig.time_sink_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(time_sink_c_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.time_sink_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(time_sink_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.time_sink_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(time_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(time_sink_c_sptr self, std::string name)"""
        return _qtgui_swig.time_sink_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(time_sink_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.time_sink_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(time_sink_c_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.time_sink_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(time_sink_c_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.time_sink_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(time_sink_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.time_sink_c_sptr_message_subscribers(self, which_port)

time_sink_c_sptr_swigregister = _qtgui_swig.time_sink_c_sptr_swigregister
time_sink_c_sptr_swigregister(time_sink_c_sptr)


time_sink_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
time_sink_c = time_sink_c.make;

class time_sink_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::time_sink_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::time_sink_f)> self) -> time_sink_f_sptr
        __init__(boost::shared_ptr<(gr::qtgui::time_sink_f)> self, time_sink_f p) -> time_sink_f_sptr
        """
        this = _qtgui_swig.new_time_sink_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(time_sink_f_sptr self) -> time_sink_f"""
        return _qtgui_swig.time_sink_f_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_time_sink_f_sptr
    __del__ = lambda self: None

    def make(self, size, samp_rate, name, nconnections=1, parent=None):
        """make(time_sink_f_sptr self, int size, double samp_rate, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_sink_f_sptr"""
        return _qtgui_swig.time_sink_f_sptr_make(self, size, samp_rate, name, nconnections, parent)


    def exec_(self):
        """exec_(time_sink_f_sptr self)"""
        return _qtgui_swig.time_sink_f_sptr_exec_(self)


    def qwidget(self):
        """qwidget(time_sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.time_sink_f_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(time_sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.time_sink_f_sptr_pyqwidget(self)


    def set_y_axis(self, min, max):
        """set_y_axis(time_sink_f_sptr self, double min, double max)"""
        return _qtgui_swig.time_sink_f_sptr_set_y_axis(self, min, max)


    def set_y_label(self, *args, **kwargs):
        """set_y_label(time_sink_f_sptr self, std::string const & label, std::string const & unit)"""
        return _qtgui_swig.time_sink_f_sptr_set_y_label(self, *args, **kwargs)


    def set_update_time(self, t):
        """set_update_time(time_sink_f_sptr self, double t)"""
        return _qtgui_swig.time_sink_f_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(time_sink_f_sptr self, std::string const & title)"""
        return _qtgui_swig.time_sink_f_sptr_set_title(self, title)


    def set_line_label(self, which, line):
        """set_line_label(time_sink_f_sptr self, int which, std::string const & line)"""
        return _qtgui_swig.time_sink_f_sptr_set_line_label(self, which, line)


    def set_line_color(self, which, color):
        """set_line_color(time_sink_f_sptr self, int which, std::string const & color)"""
        return _qtgui_swig.time_sink_f_sptr_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(time_sink_f_sptr self, int which, int width)"""
        return _qtgui_swig.time_sink_f_sptr_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(time_sink_f_sptr self, int which, int style)"""
        return _qtgui_swig.time_sink_f_sptr_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(time_sink_f_sptr self, int which, int marker)"""
        return _qtgui_swig.time_sink_f_sptr_set_line_marker(self, which, marker)


    def set_nsamps(self, newsize):
        """set_nsamps(time_sink_f_sptr self, int const newsize)"""
        return _qtgui_swig.time_sink_f_sptr_set_nsamps(self, newsize)


    def set_samp_rate(self, samp_rate):
        """set_samp_rate(time_sink_f_sptr self, double const samp_rate)"""
        return _qtgui_swig.time_sink_f_sptr_set_samp_rate(self, samp_rate)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(time_sink_f_sptr self, int which, double alpha)"""
        return _qtgui_swig.time_sink_f_sptr_set_line_alpha(self, which, alpha)


    def set_trigger_mode(self, *args, **kwargs):
        """set_trigger_mode(time_sink_f_sptr self, gr::qtgui::trigger_mode mode, gr::qtgui::trigger_slope slope, float level, float delay, int channel, std::string const & tag_key)"""
        return _qtgui_swig.time_sink_f_sptr_set_trigger_mode(self, *args, **kwargs)


    def title(self):
        """title(time_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_f_sptr_title(self)


    def line_label(self, which):
        """line_label(time_sink_f_sptr self, int which) -> std::string"""
        return _qtgui_swig.time_sink_f_sptr_line_label(self, which)


    def line_color(self, which):
        """line_color(time_sink_f_sptr self, int which) -> std::string"""
        return _qtgui_swig.time_sink_f_sptr_line_color(self, which)


    def line_width(self, which):
        """line_width(time_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.time_sink_f_sptr_line_width(self, which)


    def line_style(self, which):
        """line_style(time_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.time_sink_f_sptr_line_style(self, which)


    def line_marker(self, which):
        """line_marker(time_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.time_sink_f_sptr_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(time_sink_f_sptr self, int which) -> double"""
        return _qtgui_swig.time_sink_f_sptr_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(time_sink_f_sptr self, int width, int height)"""
        return _qtgui_swig.time_sink_f_sptr_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(time_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_f_sptr_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(time_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_f_sptr_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(time_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_f_sptr_enable_autoscale(self, en)


    def enable_stem_plot(self, en=True):
        """enable_stem_plot(time_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_f_sptr_enable_stem_plot(self, en)


    def enable_semilogx(self, en=True):
        """enable_semilogx(time_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_f_sptr_enable_semilogx(self, en)


    def enable_semilogy(self, en=True):
        """enable_semilogy(time_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_f_sptr_enable_semilogy(self, en)


    def enable_control_panel(self, en=True):
        """enable_control_panel(time_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_f_sptr_enable_control_panel(self, en)


    def enable_tags(self, which, en):
        """enable_tags(time_sink_f_sptr self, int which, bool en)"""
        return _qtgui_swig.time_sink_f_sptr_enable_tags(self, which, en)


    def disable_legend(self):
        """disable_legend(time_sink_f_sptr self)"""
        return _qtgui_swig.time_sink_f_sptr_disable_legend(self)


    def nsamps(self):
        """nsamps(time_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_sink_f_sptr_nsamps(self)


    def reset(self):
        """reset(time_sink_f_sptr self)"""
        return _qtgui_swig.time_sink_f_sptr_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.time_sink_f_sptr_d_qApplication_get, _qtgui_swig.time_sink_f_sptr_d_qApplication_set)

    def history(self):
        """history(time_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.time_sink_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(time_sink_f_sptr self, int which, int delay)
        declare_sample_delay(time_sink_f_sptr self, unsigned int delay)
        """
        return _qtgui_swig.time_sink_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(time_sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.time_sink_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(time_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_sink_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(time_sink_f_sptr self) -> double"""
        return _qtgui_swig.time_sink_f_sptr_relative_rate(self)


    def start(self):
        """start(time_sink_f_sptr self) -> bool"""
        return _qtgui_swig.time_sink_f_sptr_start(self)


    def stop(self):
        """stop(time_sink_f_sptr self) -> bool"""
        return _qtgui_swig.time_sink_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(time_sink_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.time_sink_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(time_sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.time_sink_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(time_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_sink_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(time_sink_f_sptr self, int m)"""
        return _qtgui_swig.time_sink_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(time_sink_f_sptr self)"""
        return _qtgui_swig.time_sink_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(time_sink_f_sptr self) -> bool"""
        return _qtgui_swig.time_sink_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(time_sink_f_sptr self, int m)"""
        return _qtgui_swig.time_sink_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(time_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_sink_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(time_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.time_sink_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(time_sink_f_sptr self, long max_output_buffer)
        set_max_output_buffer(time_sink_f_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.time_sink_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(time_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.time_sink_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(time_sink_f_sptr self, long min_output_buffer)
        set_min_output_buffer(time_sink_f_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.time_sink_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(time_sink_f_sptr self, int which) -> float
        pc_input_buffers_full(time_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(time_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(time_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(time_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_var(time_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(time_sink_f_sptr self, int which) -> float
        pc_output_buffers_full(time_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(time_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(time_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(time_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_var(time_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_sink_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(time_sink_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.time_sink_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(time_sink_f_sptr self)"""
        return _qtgui_swig.time_sink_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(time_sink_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.time_sink_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(time_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_sink_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(time_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_sink_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(time_sink_f_sptr self, int priority) -> int"""
        return _qtgui_swig.time_sink_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(time_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(time_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(time_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_sink_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(time_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_sink_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(time_sink_f_sptr self) -> long"""
        return _qtgui_swig.time_sink_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(time_sink_f_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.time_sink_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(time_sink_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.time_sink_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(time_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(time_sink_f_sptr self, std::string name)"""
        return _qtgui_swig.time_sink_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(time_sink_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.time_sink_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(time_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.time_sink_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(time_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.time_sink_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(time_sink_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.time_sink_f_sptr_message_subscribers(self, which_port)

time_sink_f_sptr_swigregister = _qtgui_swig.time_sink_f_sptr_swigregister
time_sink_f_sptr_swigregister(time_sink_f_sptr)


time_sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
time_sink_f = time_sink_f.make;

class time_raster_sink_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::time_raster_sink_b)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::time_raster_sink_b)> self) -> time_raster_sink_b_sptr
        __init__(boost::shared_ptr<(gr::qtgui::time_raster_sink_b)> self, time_raster_sink_b p) -> time_raster_sink_b_sptr
        """
        this = _qtgui_swig.new_time_raster_sink_b_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(time_raster_sink_b_sptr self) -> time_raster_sink_b"""
        return _qtgui_swig.time_raster_sink_b_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_time_raster_sink_b_sptr
    __del__ = lambda self: None

    def make(self, samp_rate, rows, cols, mult, offset, name, nconnections=1, parent=None):
        """make(time_raster_sink_b_sptr self, double samp_rate, double rows, double cols, pmt_vector_float mult, pmt_vector_float offset, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_raster_sink_b_sptr"""
        return _qtgui_swig.time_raster_sink_b_sptr_make(self, samp_rate, rows, cols, mult, offset, name, nconnections, parent)


    def exec_(self):
        """exec_(time_raster_sink_b_sptr self)"""
        return _qtgui_swig.time_raster_sink_b_sptr_exec_(self)


    def qwidget(self):
        """qwidget(time_raster_sink_b_sptr self) -> QWidget *"""
        return _qtgui_swig.time_raster_sink_b_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(time_raster_sink_b_sptr self) -> PyObject *"""
        return _qtgui_swig.time_raster_sink_b_sptr_pyqwidget(self)


    def set_update_time(self, t):
        """set_update_time(time_raster_sink_b_sptr self, double t)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(time_raster_sink_b_sptr self, std::string const & title)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_title(self, title)


    def set_line_label(self, which, lable):
        """set_line_label(time_raster_sink_b_sptr self, int which, std::string const & lable)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_line_label(self, which, lable)


    def set_line_color(self, which, color):
        """set_line_color(time_raster_sink_b_sptr self, int which, std::string const & color)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(time_raster_sink_b_sptr self, int which, int width)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(time_raster_sink_b_sptr self, int which, Qt::PenStyle style)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(time_raster_sink_b_sptr self, int which, QwtSymbol::Style marker)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(time_raster_sink_b_sptr self, int which, double alpha)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_line_alpha(self, which, alpha)


    def set_color_map(self, which, color):
        """set_color_map(time_raster_sink_b_sptr self, int which, int const color)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_color_map(self, which, color)


    def title(self):
        """title(time_raster_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_sptr_title(self)


    def line_label(self, which):
        """line_label(time_raster_sink_b_sptr self, int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_label(self, which)


    def line_color(self, which):
        """line_color(time_raster_sink_b_sptr self, int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_color(self, which)


    def line_width(self, which):
        """line_width(time_raster_sink_b_sptr self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_width(self, which)


    def line_style(self, which):
        """line_style(time_raster_sink_b_sptr self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_style(self, which)


    def line_marker(self, which):
        """line_marker(time_raster_sink_b_sptr self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(time_raster_sink_b_sptr self, int which) -> double"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_alpha(self, which)


    def color_map(self, which):
        """color_map(time_raster_sink_b_sptr self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_color_map(self, which)


    def set_size(self, width, height):
        """set_size(time_raster_sink_b_sptr self, int width, int height)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_size(self, width, height)


    def set_samp_rate(self, samp_rate):
        """set_samp_rate(time_raster_sink_b_sptr self, double const samp_rate)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_samp_rate(self, samp_rate)


    def set_num_rows(self, rows):
        """set_num_rows(time_raster_sink_b_sptr self, double rows)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_num_rows(self, rows)


    def set_num_cols(self, cols):
        """set_num_cols(time_raster_sink_b_sptr self, double cols)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_num_cols(self, cols)


    def num_rows(self):
        """num_rows(time_raster_sink_b_sptr self) -> double"""
        return _qtgui_swig.time_raster_sink_b_sptr_num_rows(self)


    def num_cols(self):
        """num_cols(time_raster_sink_b_sptr self) -> double"""
        return _qtgui_swig.time_raster_sink_b_sptr_num_cols(self)


    def set_multiplier(self, mult):
        """set_multiplier(time_raster_sink_b_sptr self, pmt_vector_float mult)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_multiplier(self, mult)


    def set_offset(self, offset):
        """set_offset(time_raster_sink_b_sptr self, pmt_vector_float offset)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_offset(self, offset)


    def set_intensity_range(self, min, max):
        """set_intensity_range(time_raster_sink_b_sptr self, float min, float max)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_intensity_range(self, min, max)


    def enable_menu(self, en):
        """enable_menu(time_raster_sink_b_sptr self, bool en)"""
        return _qtgui_swig.time_raster_sink_b_sptr_enable_menu(self, en)


    def enable_grid(self, en):
        """enable_grid(time_raster_sink_b_sptr self, bool en)"""
        return _qtgui_swig.time_raster_sink_b_sptr_enable_grid(self, en)


    def enable_autoscale(self, en):
        """enable_autoscale(time_raster_sink_b_sptr self, bool en)"""
        return _qtgui_swig.time_raster_sink_b_sptr_enable_autoscale(self, en)


    def reset(self):
        """reset(time_raster_sink_b_sptr self)"""
        return _qtgui_swig.time_raster_sink_b_sptr_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.time_raster_sink_b_sptr_d_qApplication_get, _qtgui_swig.time_raster_sink_b_sptr_d_qApplication_set)

    def history(self):
        """history(time_raster_sink_b_sptr self) -> unsigned int"""
        return _qtgui_swig.time_raster_sink_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(time_raster_sink_b_sptr self, int which, int delay)
        declare_sample_delay(time_raster_sink_b_sptr self, unsigned int delay)
        """
        return _qtgui_swig.time_raster_sink_b_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(time_raster_sink_b_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.time_raster_sink_b_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(time_raster_sink_b_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(time_raster_sink_b_sptr self) -> double"""
        return _qtgui_swig.time_raster_sink_b_sptr_relative_rate(self)


    def start(self):
        """start(time_raster_sink_b_sptr self) -> bool"""
        return _qtgui_swig.time_raster_sink_b_sptr_start(self)


    def stop(self):
        """stop(time_raster_sink_b_sptr self) -> bool"""
        return _qtgui_swig.time_raster_sink_b_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(time_raster_sink_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.time_raster_sink_b_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(time_raster_sink_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.time_raster_sink_b_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(time_raster_sink_b_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(time_raster_sink_b_sptr self, int m)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(time_raster_sink_b_sptr self)"""
        return _qtgui_swig.time_raster_sink_b_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(time_raster_sink_b_sptr self) -> bool"""
        return _qtgui_swig.time_raster_sink_b_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(time_raster_sink_b_sptr self, int m)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(time_raster_sink_b_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(time_raster_sink_b_sptr self, int i) -> long"""
        return _qtgui_swig.time_raster_sink_b_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(time_raster_sink_b_sptr self, long max_output_buffer)
        set_max_output_buffer(time_raster_sink_b_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.time_raster_sink_b_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(time_raster_sink_b_sptr self, int i) -> long"""
        return _qtgui_swig.time_raster_sink_b_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(time_raster_sink_b_sptr self, long min_output_buffer)
        set_min_output_buffer(time_raster_sink_b_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.time_raster_sink_b_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(time_raster_sink_b_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_b_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(time_raster_sink_b_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_b_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(time_raster_sink_b_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_b_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(time_raster_sink_b_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(time_raster_sink_b_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_b_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(time_raster_sink_b_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_b_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(time_raster_sink_b_sptr self, int which) -> float
        pc_input_buffers_full(time_raster_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_b_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(time_raster_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(time_raster_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_b_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(time_raster_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_var(time_raster_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_b_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(time_raster_sink_b_sptr self, int which) -> float
        pc_output_buffers_full(time_raster_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_b_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(time_raster_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(time_raster_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_b_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(time_raster_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_var(time_raster_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_b_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(time_raster_sink_b_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_b_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(time_raster_sink_b_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_b_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(time_raster_sink_b_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_b_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(time_raster_sink_b_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_b_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(time_raster_sink_b_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_b_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(time_raster_sink_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(time_raster_sink_b_sptr self)"""
        return _qtgui_swig.time_raster_sink_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(time_raster_sink_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.time_raster_sink_b_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(time_raster_sink_b_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(time_raster_sink_b_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(time_raster_sink_b_sptr self, int priority) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(time_raster_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_sptr_name(self)


    def symbol_name(self):
        """symbol_name(time_raster_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(time_raster_sink_b_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_raster_sink_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(time_raster_sink_b_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_raster_sink_b_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(time_raster_sink_b_sptr self) -> long"""
        return _qtgui_swig.time_raster_sink_b_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(time_raster_sink_b_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.time_raster_sink_b_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(time_raster_sink_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.time_raster_sink_b_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(time_raster_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(time_raster_sink_b_sptr self, std::string name)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(time_raster_sink_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.time_raster_sink_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(time_raster_sink_b_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.time_raster_sink_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(time_raster_sink_b_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.time_raster_sink_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(time_raster_sink_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.time_raster_sink_b_sptr_message_subscribers(self, which_port)

time_raster_sink_b_sptr_swigregister = _qtgui_swig.time_raster_sink_b_sptr_swigregister
time_raster_sink_b_sptr_swigregister(time_raster_sink_b_sptr)


time_raster_sink_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
time_raster_sink_b = time_raster_sink_b.make;

class time_raster_sink_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::time_raster_sink_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::time_raster_sink_f)> self) -> time_raster_sink_f_sptr
        __init__(boost::shared_ptr<(gr::qtgui::time_raster_sink_f)> self, time_raster_sink_f p) -> time_raster_sink_f_sptr
        """
        this = _qtgui_swig.new_time_raster_sink_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(time_raster_sink_f_sptr self) -> time_raster_sink_f"""
        return _qtgui_swig.time_raster_sink_f_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_time_raster_sink_f_sptr
    __del__ = lambda self: None

    def make(self, samp_rate, rows, cols, mult, offset, name, nconnections=1, parent=None):
        """make(time_raster_sink_f_sptr self, double samp_rate, double rows, double cols, pmt_vector_float mult, pmt_vector_float offset, std::string const & name, int nconnections=1, QWidget * parent=None) -> time_raster_sink_f_sptr"""
        return _qtgui_swig.time_raster_sink_f_sptr_make(self, samp_rate, rows, cols, mult, offset, name, nconnections, parent)


    def exec_(self):
        """exec_(time_raster_sink_f_sptr self)"""
        return _qtgui_swig.time_raster_sink_f_sptr_exec_(self)


    def qwidget(self):
        """qwidget(time_raster_sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.time_raster_sink_f_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(time_raster_sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.time_raster_sink_f_sptr_pyqwidget(self)


    def set_update_time(self, t):
        """set_update_time(time_raster_sink_f_sptr self, double t)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(time_raster_sink_f_sptr self, std::string const & title)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_title(self, title)


    def set_line_label(self, which, lable):
        """set_line_label(time_raster_sink_f_sptr self, int which, std::string const & lable)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_line_label(self, which, lable)


    def set_line_color(self, which, color):
        """set_line_color(time_raster_sink_f_sptr self, int which, std::string const & color)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(time_raster_sink_f_sptr self, int which, int width)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(time_raster_sink_f_sptr self, int which, Qt::PenStyle style)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(time_raster_sink_f_sptr self, int which, QwtSymbol::Style marker)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(time_raster_sink_f_sptr self, int which, double alpha)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_line_alpha(self, which, alpha)


    def set_color_map(self, which, color):
        """set_color_map(time_raster_sink_f_sptr self, int which, int const color)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_color_map(self, which, color)


    def title(self):
        """title(time_raster_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_sptr_title(self)


    def line_label(self, which):
        """line_label(time_raster_sink_f_sptr self, int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_label(self, which)


    def line_color(self, which):
        """line_color(time_raster_sink_f_sptr self, int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_color(self, which)


    def line_width(self, which):
        """line_width(time_raster_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_width(self, which)


    def line_style(self, which):
        """line_style(time_raster_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_style(self, which)


    def line_marker(self, which):
        """line_marker(time_raster_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(time_raster_sink_f_sptr self, int which) -> double"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_alpha(self, which)


    def color_map(self, which):
        """color_map(time_raster_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_color_map(self, which)


    def set_size(self, width, height):
        """set_size(time_raster_sink_f_sptr self, int width, int height)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_size(self, width, height)


    def set_samp_rate(self, samp_rate):
        """set_samp_rate(time_raster_sink_f_sptr self, double const samp_rate)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_samp_rate(self, samp_rate)


    def set_num_rows(self, rows):
        """set_num_rows(time_raster_sink_f_sptr self, double rows)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_num_rows(self, rows)


    def set_num_cols(self, cols):
        """set_num_cols(time_raster_sink_f_sptr self, double cols)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_num_cols(self, cols)


    def num_rows(self):
        """num_rows(time_raster_sink_f_sptr self) -> double"""
        return _qtgui_swig.time_raster_sink_f_sptr_num_rows(self)


    def num_cols(self):
        """num_cols(time_raster_sink_f_sptr self) -> double"""
        return _qtgui_swig.time_raster_sink_f_sptr_num_cols(self)


    def set_multiplier(self, mult):
        """set_multiplier(time_raster_sink_f_sptr self, pmt_vector_float mult)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_multiplier(self, mult)


    def set_offset(self, offset):
        """set_offset(time_raster_sink_f_sptr self, pmt_vector_float offset)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_offset(self, offset)


    def set_intensity_range(self, min, max):
        """set_intensity_range(time_raster_sink_f_sptr self, float min, float max)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_intensity_range(self, min, max)


    def enable_menu(self, en):
        """enable_menu(time_raster_sink_f_sptr self, bool en)"""
        return _qtgui_swig.time_raster_sink_f_sptr_enable_menu(self, en)


    def enable_grid(self, en):
        """enable_grid(time_raster_sink_f_sptr self, bool en)"""
        return _qtgui_swig.time_raster_sink_f_sptr_enable_grid(self, en)


    def enable_autoscale(self, en):
        """enable_autoscale(time_raster_sink_f_sptr self, bool en)"""
        return _qtgui_swig.time_raster_sink_f_sptr_enable_autoscale(self, en)


    def reset(self):
        """reset(time_raster_sink_f_sptr self)"""
        return _qtgui_swig.time_raster_sink_f_sptr_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.time_raster_sink_f_sptr_d_qApplication_get, _qtgui_swig.time_raster_sink_f_sptr_d_qApplication_set)

    def history(self):
        """history(time_raster_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.time_raster_sink_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(time_raster_sink_f_sptr self, int which, int delay)
        declare_sample_delay(time_raster_sink_f_sptr self, unsigned int delay)
        """
        return _qtgui_swig.time_raster_sink_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(time_raster_sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.time_raster_sink_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(time_raster_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(time_raster_sink_f_sptr self) -> double"""
        return _qtgui_swig.time_raster_sink_f_sptr_relative_rate(self)


    def start(self):
        """start(time_raster_sink_f_sptr self) -> bool"""
        return _qtgui_swig.time_raster_sink_f_sptr_start(self)


    def stop(self):
        """stop(time_raster_sink_f_sptr self) -> bool"""
        return _qtgui_swig.time_raster_sink_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(time_raster_sink_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.time_raster_sink_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(time_raster_sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.time_raster_sink_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(time_raster_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(time_raster_sink_f_sptr self, int m)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(time_raster_sink_f_sptr self)"""
        return _qtgui_swig.time_raster_sink_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(time_raster_sink_f_sptr self) -> bool"""
        return _qtgui_swig.time_raster_sink_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(time_raster_sink_f_sptr self, int m)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(time_raster_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(time_raster_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.time_raster_sink_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(time_raster_sink_f_sptr self, long max_output_buffer)
        set_max_output_buffer(time_raster_sink_f_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.time_raster_sink_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(time_raster_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.time_raster_sink_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(time_raster_sink_f_sptr self, long min_output_buffer)
        set_min_output_buffer(time_raster_sink_f_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.time_raster_sink_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(time_raster_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(time_raster_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(time_raster_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(time_raster_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(time_raster_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(time_raster_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(time_raster_sink_f_sptr self, int which) -> float
        pc_input_buffers_full(time_raster_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(time_raster_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(time_raster_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(time_raster_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_var(time_raster_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(time_raster_sink_f_sptr self, int which) -> float
        pc_output_buffers_full(time_raster_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(time_raster_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(time_raster_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(time_raster_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_var(time_raster_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.time_raster_sink_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(time_raster_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(time_raster_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(time_raster_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(time_raster_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(time_raster_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_raster_sink_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(time_raster_sink_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(time_raster_sink_f_sptr self)"""
        return _qtgui_swig.time_raster_sink_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(time_raster_sink_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.time_raster_sink_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(time_raster_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(time_raster_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(time_raster_sink_f_sptr self, int priority) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(time_raster_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(time_raster_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(time_raster_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_raster_sink_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(time_raster_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_raster_sink_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(time_raster_sink_f_sptr self) -> long"""
        return _qtgui_swig.time_raster_sink_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(time_raster_sink_f_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.time_raster_sink_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(time_raster_sink_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.time_raster_sink_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(time_raster_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(time_raster_sink_f_sptr self, std::string name)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(time_raster_sink_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.time_raster_sink_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(time_raster_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.time_raster_sink_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(time_raster_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.time_raster_sink_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(time_raster_sink_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.time_raster_sink_f_sptr_message_subscribers(self, which_port)

time_raster_sink_f_sptr_swigregister = _qtgui_swig.time_raster_sink_f_sptr_swigregister
time_raster_sink_f_sptr_swigregister(time_raster_sink_f_sptr)


time_raster_sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
time_raster_sink_f = time_raster_sink_f.make;

class freq_sink_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::freq_sink_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::freq_sink_c)> self) -> freq_sink_c_sptr
        __init__(boost::shared_ptr<(gr::qtgui::freq_sink_c)> self, freq_sink_c p) -> freq_sink_c_sptr
        """
        this = _qtgui_swig.new_freq_sink_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(freq_sink_c_sptr self) -> freq_sink_c"""
        return _qtgui_swig.freq_sink_c_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_freq_sink_c_sptr
    __del__ = lambda self: None

    def make(self, fftsize, wintype, fc, bw, name, nconnections=1, parent=None):
        """make(freq_sink_c_sptr self, int fftsize, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> freq_sink_c_sptr"""
        return _qtgui_swig.freq_sink_c_sptr_make(self, fftsize, wintype, fc, bw, name, nconnections, parent)


    def exec_(self):
        """exec_(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_exec_(self)


    def qwidget(self):
        """qwidget(freq_sink_c_sptr self) -> QWidget *"""
        return _qtgui_swig.freq_sink_c_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(freq_sink_c_sptr self) -> PyObject *"""
        return _qtgui_swig.freq_sink_c_sptr_pyqwidget(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(freq_sink_c_sptr self, int const fftsize)"""
        return _qtgui_swig.freq_sink_c_sptr_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(freq_sink_c_sptr self) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_fft_size(self)


    def set_fft_average(self, fftavg):
        """set_fft_average(freq_sink_c_sptr self, float const fftavg)"""
        return _qtgui_swig.freq_sink_c_sptr_set_fft_average(self, fftavg)


    def fft_average(self):
        """fft_average(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_fft_average(self)


    def set_fft_window(self, win):
        """set_fft_window(freq_sink_c_sptr self, gr::filter::firdes::win_type const win)"""
        return _qtgui_swig.freq_sink_c_sptr_set_fft_window(self, win)


    def fft_window(self):
        """fft_window(freq_sink_c_sptr self) -> gr::filter::firdes::win_type"""
        return _qtgui_swig.freq_sink_c_sptr_fft_window(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(freq_sink_c_sptr self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.freq_sink_c_sptr_set_frequency_range(self, centerfreq, bandwidth)


    def set_y_axis(self, min, max):
        """set_y_axis(freq_sink_c_sptr self, double min, double max)"""
        return _qtgui_swig.freq_sink_c_sptr_set_y_axis(self, min, max)


    def set_update_time(self, t):
        """set_update_time(freq_sink_c_sptr self, double t)"""
        return _qtgui_swig.freq_sink_c_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(freq_sink_c_sptr self, std::string const & title)"""
        return _qtgui_swig.freq_sink_c_sptr_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(freq_sink_c_sptr self, int which, std::string const & label)"""
        return _qtgui_swig.freq_sink_c_sptr_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(freq_sink_c_sptr self, int which, std::string const & color)"""
        return _qtgui_swig.freq_sink_c_sptr_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(freq_sink_c_sptr self, int which, int width)"""
        return _qtgui_swig.freq_sink_c_sptr_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(freq_sink_c_sptr self, int which, int style)"""
        return _qtgui_swig.freq_sink_c_sptr_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(freq_sink_c_sptr self, int which, int marker)"""
        return _qtgui_swig.freq_sink_c_sptr_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(freq_sink_c_sptr self, int which, double alpha)"""
        return _qtgui_swig.freq_sink_c_sptr_set_line_alpha(self, which, alpha)


    def set_trigger_mode(self, *args, **kwargs):
        """set_trigger_mode(freq_sink_c_sptr self, gr::qtgui::trigger_mode mode, float level, int channel, std::string const & tag_key)"""
        return _qtgui_swig.freq_sink_c_sptr_set_trigger_mode(self, *args, **kwargs)


    def title(self):
        """title(freq_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_title(self)


    def line_label(self, which):
        """line_label(freq_sink_c_sptr self, int which) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_line_label(self, which)


    def line_color(self, which):
        """line_color(freq_sink_c_sptr self, int which) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_line_color(self, which)


    def line_width(self, which):
        """line_width(freq_sink_c_sptr self, int which) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_line_width(self, which)


    def line_style(self, which):
        """line_style(freq_sink_c_sptr self, int which) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_line_style(self, which)


    def line_marker(self, which):
        """line_marker(freq_sink_c_sptr self, int which) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(freq_sink_c_sptr self, int which) -> double"""
        return _qtgui_swig.freq_sink_c_sptr_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(freq_sink_c_sptr self, int width, int height)"""
        return _qtgui_swig.freq_sink_c_sptr_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(freq_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.freq_sink_c_sptr_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(freq_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.freq_sink_c_sptr_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(freq_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.freq_sink_c_sptr_enable_autoscale(self, en)


    def enable_control_panel(self, en=True):
        """enable_control_panel(freq_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.freq_sink_c_sptr_enable_control_panel(self, en)


    def enable_max_hold(self, en):
        """enable_max_hold(freq_sink_c_sptr self, bool en)"""
        return _qtgui_swig.freq_sink_c_sptr_enable_max_hold(self, en)


    def enable_min_hold(self, en):
        """enable_min_hold(freq_sink_c_sptr self, bool en)"""
        return _qtgui_swig.freq_sink_c_sptr_enable_min_hold(self, en)


    def clear_max_hold(self):
        """clear_max_hold(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_clear_max_hold(self)


    def clear_min_hold(self):
        """clear_min_hold(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_clear_min_hold(self)


    def disable_legend(self):
        """disable_legend(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_disable_legend(self)


    def reset(self):
        """reset(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.freq_sink_c_sptr_d_qApplication_get, _qtgui_swig.freq_sink_c_sptr_d_qApplication_set)

    def history(self):
        """history(freq_sink_c_sptr self) -> unsigned int"""
        return _qtgui_swig.freq_sink_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(freq_sink_c_sptr self, int which, int delay)
        declare_sample_delay(freq_sink_c_sptr self, unsigned int delay)
        """
        return _qtgui_swig.freq_sink_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(freq_sink_c_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.freq_sink_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(freq_sink_c_sptr self) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(freq_sink_c_sptr self) -> double"""
        return _qtgui_swig.freq_sink_c_sptr_relative_rate(self)


    def start(self):
        """start(freq_sink_c_sptr self) -> bool"""
        return _qtgui_swig.freq_sink_c_sptr_start(self)


    def stop(self):
        """stop(freq_sink_c_sptr self) -> bool"""
        return _qtgui_swig.freq_sink_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(freq_sink_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.freq_sink_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(freq_sink_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.freq_sink_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(freq_sink_c_sptr self) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(freq_sink_c_sptr self, int m)"""
        return _qtgui_swig.freq_sink_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(freq_sink_c_sptr self) -> bool"""
        return _qtgui_swig.freq_sink_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(freq_sink_c_sptr self, int m)"""
        return _qtgui_swig.freq_sink_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(freq_sink_c_sptr self) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(freq_sink_c_sptr self, int i) -> long"""
        return _qtgui_swig.freq_sink_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(freq_sink_c_sptr self, long max_output_buffer)
        set_max_output_buffer(freq_sink_c_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.freq_sink_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(freq_sink_c_sptr self, int i) -> long"""
        return _qtgui_swig.freq_sink_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(freq_sink_c_sptr self, long min_output_buffer)
        set_min_output_buffer(freq_sink_c_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.freq_sink_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(freq_sink_c_sptr self, int which) -> float
        pc_input_buffers_full(freq_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(freq_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(freq_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(freq_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_var(freq_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(freq_sink_c_sptr self, int which) -> float
        pc_output_buffers_full(freq_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(freq_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(freq_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(freq_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_var(freq_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(freq_sink_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.freq_sink_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(freq_sink_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.freq_sink_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(freq_sink_c_sptr self) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(freq_sink_c_sptr self) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(freq_sink_c_sptr self, int priority) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(freq_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(freq_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(freq_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.freq_sink_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(freq_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.freq_sink_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(freq_sink_c_sptr self) -> long"""
        return _qtgui_swig.freq_sink_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(freq_sink_c_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.freq_sink_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(freq_sink_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.freq_sink_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(freq_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(freq_sink_c_sptr self, std::string name)"""
        return _qtgui_swig.freq_sink_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(freq_sink_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.freq_sink_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(freq_sink_c_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.freq_sink_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(freq_sink_c_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.freq_sink_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(freq_sink_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.freq_sink_c_sptr_message_subscribers(self, which_port)

freq_sink_c_sptr_swigregister = _qtgui_swig.freq_sink_c_sptr_swigregister
freq_sink_c_sptr_swigregister(freq_sink_c_sptr)


freq_sink_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
freq_sink_c = freq_sink_c.make;

class freq_sink_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::freq_sink_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::freq_sink_f)> self) -> freq_sink_f_sptr
        __init__(boost::shared_ptr<(gr::qtgui::freq_sink_f)> self, freq_sink_f p) -> freq_sink_f_sptr
        """
        this = _qtgui_swig.new_freq_sink_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(freq_sink_f_sptr self) -> freq_sink_f"""
        return _qtgui_swig.freq_sink_f_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_freq_sink_f_sptr
    __del__ = lambda self: None

    def make(self, fftsize, wintype, fc, bw, name, nconnections=1, parent=None):
        """make(freq_sink_f_sptr self, int fftsize, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> freq_sink_f_sptr"""
        return _qtgui_swig.freq_sink_f_sptr_make(self, fftsize, wintype, fc, bw, name, nconnections, parent)


    def exec_(self):
        """exec_(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_exec_(self)


    def qwidget(self):
        """qwidget(freq_sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.freq_sink_f_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(freq_sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.freq_sink_f_sptr_pyqwidget(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(freq_sink_f_sptr self, int const fftsize)"""
        return _qtgui_swig.freq_sink_f_sptr_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(freq_sink_f_sptr self) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_fft_size(self)


    def set_fft_average(self, fftavg):
        """set_fft_average(freq_sink_f_sptr self, float const fftavg)"""
        return _qtgui_swig.freq_sink_f_sptr_set_fft_average(self, fftavg)


    def fft_average(self):
        """fft_average(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_fft_average(self)


    def set_fft_window(self, win):
        """set_fft_window(freq_sink_f_sptr self, gr::filter::firdes::win_type const win)"""
        return _qtgui_swig.freq_sink_f_sptr_set_fft_window(self, win)


    def fft_window(self):
        """fft_window(freq_sink_f_sptr self) -> gr::filter::firdes::win_type"""
        return _qtgui_swig.freq_sink_f_sptr_fft_window(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(freq_sink_f_sptr self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.freq_sink_f_sptr_set_frequency_range(self, centerfreq, bandwidth)


    def set_y_axis(self, min, max):
        """set_y_axis(freq_sink_f_sptr self, double min, double max)"""
        return _qtgui_swig.freq_sink_f_sptr_set_y_axis(self, min, max)


    def set_update_time(self, t):
        """set_update_time(freq_sink_f_sptr self, double t)"""
        return _qtgui_swig.freq_sink_f_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(freq_sink_f_sptr self, std::string const & title)"""
        return _qtgui_swig.freq_sink_f_sptr_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(freq_sink_f_sptr self, int which, std::string const & label)"""
        return _qtgui_swig.freq_sink_f_sptr_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(freq_sink_f_sptr self, int which, std::string const & color)"""
        return _qtgui_swig.freq_sink_f_sptr_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(freq_sink_f_sptr self, int which, int width)"""
        return _qtgui_swig.freq_sink_f_sptr_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(freq_sink_f_sptr self, int which, int style)"""
        return _qtgui_swig.freq_sink_f_sptr_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(freq_sink_f_sptr self, int which, int marker)"""
        return _qtgui_swig.freq_sink_f_sptr_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(freq_sink_f_sptr self, int which, double alpha)"""
        return _qtgui_swig.freq_sink_f_sptr_set_line_alpha(self, which, alpha)


    def set_plot_pos_half(self, half):
        """set_plot_pos_half(freq_sink_f_sptr self, bool half)"""
        return _qtgui_swig.freq_sink_f_sptr_set_plot_pos_half(self, half)


    def set_trigger_mode(self, *args, **kwargs):
        """set_trigger_mode(freq_sink_f_sptr self, gr::qtgui::trigger_mode mode, float level, int channel, std::string const & tag_key)"""
        return _qtgui_swig.freq_sink_f_sptr_set_trigger_mode(self, *args, **kwargs)


    def title(self):
        """title(freq_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_title(self)


    def line_label(self, which):
        """line_label(freq_sink_f_sptr self, int which) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_line_label(self, which)


    def line_color(self, which):
        """line_color(freq_sink_f_sptr self, int which) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_line_color(self, which)


    def line_width(self, which):
        """line_width(freq_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_line_width(self, which)


    def line_style(self, which):
        """line_style(freq_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_line_style(self, which)


    def line_marker(self, which):
        """line_marker(freq_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(freq_sink_f_sptr self, int which) -> double"""
        return _qtgui_swig.freq_sink_f_sptr_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(freq_sink_f_sptr self, int width, int height)"""
        return _qtgui_swig.freq_sink_f_sptr_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(freq_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.freq_sink_f_sptr_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(freq_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.freq_sink_f_sptr_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(freq_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.freq_sink_f_sptr_enable_autoscale(self, en)


    def enable_control_panel(self, en=True):
        """enable_control_panel(freq_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.freq_sink_f_sptr_enable_control_panel(self, en)


    def enable_max_hold(self, en):
        """enable_max_hold(freq_sink_f_sptr self, bool en)"""
        return _qtgui_swig.freq_sink_f_sptr_enable_max_hold(self, en)


    def enable_min_hold(self, en):
        """enable_min_hold(freq_sink_f_sptr self, bool en)"""
        return _qtgui_swig.freq_sink_f_sptr_enable_min_hold(self, en)


    def clear_max_hold(self):
        """clear_max_hold(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_clear_max_hold(self)


    def clear_min_hold(self):
        """clear_min_hold(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_clear_min_hold(self)


    def disable_legend(self):
        """disable_legend(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_disable_legend(self)


    def reset(self):
        """reset(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.freq_sink_f_sptr_d_qApplication_get, _qtgui_swig.freq_sink_f_sptr_d_qApplication_set)

    def history(self):
        """history(freq_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.freq_sink_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(freq_sink_f_sptr self, int which, int delay)
        declare_sample_delay(freq_sink_f_sptr self, unsigned int delay)
        """
        return _qtgui_swig.freq_sink_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(freq_sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.freq_sink_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(freq_sink_f_sptr self) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(freq_sink_f_sptr self) -> double"""
        return _qtgui_swig.freq_sink_f_sptr_relative_rate(self)


    def start(self):
        """start(freq_sink_f_sptr self) -> bool"""
        return _qtgui_swig.freq_sink_f_sptr_start(self)


    def stop(self):
        """stop(freq_sink_f_sptr self) -> bool"""
        return _qtgui_swig.freq_sink_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(freq_sink_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.freq_sink_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(freq_sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.freq_sink_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(freq_sink_f_sptr self) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(freq_sink_f_sptr self, int m)"""
        return _qtgui_swig.freq_sink_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(freq_sink_f_sptr self) -> bool"""
        return _qtgui_swig.freq_sink_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(freq_sink_f_sptr self, int m)"""
        return _qtgui_swig.freq_sink_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(freq_sink_f_sptr self) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(freq_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.freq_sink_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(freq_sink_f_sptr self, long max_output_buffer)
        set_max_output_buffer(freq_sink_f_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.freq_sink_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(freq_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.freq_sink_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(freq_sink_f_sptr self, long min_output_buffer)
        set_min_output_buffer(freq_sink_f_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.freq_sink_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(freq_sink_f_sptr self, int which) -> float
        pc_input_buffers_full(freq_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(freq_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(freq_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(freq_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_var(freq_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(freq_sink_f_sptr self, int which) -> float
        pc_output_buffers_full(freq_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(freq_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(freq_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(freq_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_var(freq_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.freq_sink_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(freq_sink_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.freq_sink_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(freq_sink_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.freq_sink_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(freq_sink_f_sptr self) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(freq_sink_f_sptr self) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(freq_sink_f_sptr self, int priority) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(freq_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(freq_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(freq_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.freq_sink_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(freq_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.freq_sink_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(freq_sink_f_sptr self) -> long"""
        return _qtgui_swig.freq_sink_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(freq_sink_f_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.freq_sink_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(freq_sink_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.freq_sink_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(freq_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(freq_sink_f_sptr self, std::string name)"""
        return _qtgui_swig.freq_sink_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(freq_sink_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.freq_sink_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(freq_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.freq_sink_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(freq_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.freq_sink_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(freq_sink_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.freq_sink_f_sptr_message_subscribers(self, which_port)

freq_sink_f_sptr_swigregister = _qtgui_swig.freq_sink_f_sptr_swigregister
freq_sink_f_sptr_swigregister(freq_sink_f_sptr)


freq_sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
freq_sink_f = freq_sink_f.make;

class const_sink_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::const_sink_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::const_sink_c)> self) -> const_sink_c_sptr
        __init__(boost::shared_ptr<(gr::qtgui::const_sink_c)> self, const_sink_c p) -> const_sink_c_sptr
        """
        this = _qtgui_swig.new_const_sink_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(const_sink_c_sptr self) -> const_sink_c"""
        return _qtgui_swig.const_sink_c_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_const_sink_c_sptr
    __del__ = lambda self: None

    def make(self, size, name, nconnections=1, parent=None):
        """make(const_sink_c_sptr self, int size, std::string const & name, int nconnections=1, QWidget * parent=None) -> const_sink_c_sptr"""
        return _qtgui_swig.const_sink_c_sptr_make(self, size, name, nconnections, parent)


    def exec_(self):
        """exec_(const_sink_c_sptr self)"""
        return _qtgui_swig.const_sink_c_sptr_exec_(self)


    def qwidget(self):
        """qwidget(const_sink_c_sptr self) -> QWidget *"""
        return _qtgui_swig.const_sink_c_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(const_sink_c_sptr self) -> PyObject *"""
        return _qtgui_swig.const_sink_c_sptr_pyqwidget(self)


    def set_y_axis(self, min, max):
        """set_y_axis(const_sink_c_sptr self, double min, double max)"""
        return _qtgui_swig.const_sink_c_sptr_set_y_axis(self, min, max)


    def set_x_axis(self, min, max):
        """set_x_axis(const_sink_c_sptr self, double min, double max)"""
        return _qtgui_swig.const_sink_c_sptr_set_x_axis(self, min, max)


    def set_update_time(self, t):
        """set_update_time(const_sink_c_sptr self, double t)"""
        return _qtgui_swig.const_sink_c_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(const_sink_c_sptr self, std::string const & title)"""
        return _qtgui_swig.const_sink_c_sptr_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(const_sink_c_sptr self, int which, std::string const & label)"""
        return _qtgui_swig.const_sink_c_sptr_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(const_sink_c_sptr self, int which, std::string const & color)"""
        return _qtgui_swig.const_sink_c_sptr_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(const_sink_c_sptr self, int which, int width)"""
        return _qtgui_swig.const_sink_c_sptr_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(const_sink_c_sptr self, int which, int style)"""
        return _qtgui_swig.const_sink_c_sptr_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(const_sink_c_sptr self, int which, int marker)"""
        return _qtgui_swig.const_sink_c_sptr_set_line_marker(self, which, marker)


    def set_nsamps(self, newsize):
        """set_nsamps(const_sink_c_sptr self, int const newsize)"""
        return _qtgui_swig.const_sink_c_sptr_set_nsamps(self, newsize)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(const_sink_c_sptr self, int which, double alpha)"""
        return _qtgui_swig.const_sink_c_sptr_set_line_alpha(self, which, alpha)


    def set_trigger_mode(self, *args, **kwargs):
        """set_trigger_mode(const_sink_c_sptr self, gr::qtgui::trigger_mode mode, gr::qtgui::trigger_slope slope, float level, int channel, std::string const & tag_key)"""
        return _qtgui_swig.const_sink_c_sptr_set_trigger_mode(self, *args, **kwargs)


    def title(self):
        """title(const_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_title(self)


    def line_label(self, which):
        """line_label(const_sink_c_sptr self, int which) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_line_label(self, which)


    def line_color(self, which):
        """line_color(const_sink_c_sptr self, int which) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_line_color(self, which)


    def line_width(self, which):
        """line_width(const_sink_c_sptr self, int which) -> int"""
        return _qtgui_swig.const_sink_c_sptr_line_width(self, which)


    def line_style(self, which):
        """line_style(const_sink_c_sptr self, int which) -> int"""
        return _qtgui_swig.const_sink_c_sptr_line_style(self, which)


    def line_marker(self, which):
        """line_marker(const_sink_c_sptr self, int which) -> int"""
        return _qtgui_swig.const_sink_c_sptr_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(const_sink_c_sptr self, int which) -> double"""
        return _qtgui_swig.const_sink_c_sptr_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(const_sink_c_sptr self, int width, int height)"""
        return _qtgui_swig.const_sink_c_sptr_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(const_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.const_sink_c_sptr_enable_menu(self, en)


    def enable_autoscale(self, en):
        """enable_autoscale(const_sink_c_sptr self, bool en)"""
        return _qtgui_swig.const_sink_c_sptr_enable_autoscale(self, en)


    def enable_grid(self, en):
        """enable_grid(const_sink_c_sptr self, bool en)"""
        return _qtgui_swig.const_sink_c_sptr_enable_grid(self, en)


    def disable_legend(self):
        """disable_legend(const_sink_c_sptr self)"""
        return _qtgui_swig.const_sink_c_sptr_disable_legend(self)


    def nsamps(self):
        """nsamps(const_sink_c_sptr self) -> int"""
        return _qtgui_swig.const_sink_c_sptr_nsamps(self)


    def reset(self):
        """reset(const_sink_c_sptr self)"""
        return _qtgui_swig.const_sink_c_sptr_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.const_sink_c_sptr_d_qApplication_get, _qtgui_swig.const_sink_c_sptr_d_qApplication_set)

    def history(self):
        """history(const_sink_c_sptr self) -> unsigned int"""
        return _qtgui_swig.const_sink_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(const_sink_c_sptr self, int which, int delay)
        declare_sample_delay(const_sink_c_sptr self, unsigned int delay)
        """
        return _qtgui_swig.const_sink_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(const_sink_c_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.const_sink_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(const_sink_c_sptr self) -> int"""
        return _qtgui_swig.const_sink_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(const_sink_c_sptr self) -> double"""
        return _qtgui_swig.const_sink_c_sptr_relative_rate(self)


    def start(self):
        """start(const_sink_c_sptr self) -> bool"""
        return _qtgui_swig.const_sink_c_sptr_start(self)


    def stop(self):
        """stop(const_sink_c_sptr self) -> bool"""
        return _qtgui_swig.const_sink_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(const_sink_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.const_sink_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(const_sink_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.const_sink_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(const_sink_c_sptr self) -> int"""
        return _qtgui_swig.const_sink_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(const_sink_c_sptr self, int m)"""
        return _qtgui_swig.const_sink_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(const_sink_c_sptr self)"""
        return _qtgui_swig.const_sink_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(const_sink_c_sptr self) -> bool"""
        return _qtgui_swig.const_sink_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(const_sink_c_sptr self, int m)"""
        return _qtgui_swig.const_sink_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(const_sink_c_sptr self) -> int"""
        return _qtgui_swig.const_sink_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(const_sink_c_sptr self, int i) -> long"""
        return _qtgui_swig.const_sink_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(const_sink_c_sptr self, long max_output_buffer)
        set_max_output_buffer(const_sink_c_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.const_sink_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(const_sink_c_sptr self, int i) -> long"""
        return _qtgui_swig.const_sink_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(const_sink_c_sptr self, long min_output_buffer)
        set_min_output_buffer(const_sink_c_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.const_sink_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(const_sink_c_sptr self, int which) -> float
        pc_input_buffers_full(const_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.const_sink_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(const_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(const_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.const_sink_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(const_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_var(const_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.const_sink_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(const_sink_c_sptr self, int which) -> float
        pc_output_buffers_full(const_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.const_sink_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(const_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(const_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.const_sink_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(const_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_var(const_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.const_sink_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(const_sink_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.const_sink_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(const_sink_c_sptr self)"""
        return _qtgui_swig.const_sink_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(const_sink_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.const_sink_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(const_sink_c_sptr self) -> int"""
        return _qtgui_swig.const_sink_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(const_sink_c_sptr self) -> int"""
        return _qtgui_swig.const_sink_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(const_sink_c_sptr self, int priority) -> int"""
        return _qtgui_swig.const_sink_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(const_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(const_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(const_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.const_sink_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(const_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.const_sink_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(const_sink_c_sptr self) -> long"""
        return _qtgui_swig.const_sink_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(const_sink_c_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.const_sink_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(const_sink_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.const_sink_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(const_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(const_sink_c_sptr self, std::string name)"""
        return _qtgui_swig.const_sink_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(const_sink_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.const_sink_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(const_sink_c_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.const_sink_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(const_sink_c_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.const_sink_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(const_sink_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.const_sink_c_sptr_message_subscribers(self, which_port)

const_sink_c_sptr_swigregister = _qtgui_swig.const_sink_c_sptr_swigregister
const_sink_c_sptr_swigregister(const_sink_c_sptr)


const_sink_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
const_sink_c = const_sink_c.make;

class waterfall_sink_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::waterfall_sink_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::waterfall_sink_c)> self) -> waterfall_sink_c_sptr
        __init__(boost::shared_ptr<(gr::qtgui::waterfall_sink_c)> self, waterfall_sink_c p) -> waterfall_sink_c_sptr
        """
        this = _qtgui_swig.new_waterfall_sink_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(waterfall_sink_c_sptr self) -> waterfall_sink_c"""
        return _qtgui_swig.waterfall_sink_c_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_waterfall_sink_c_sptr
    __del__ = lambda self: None

    def make(self, size, wintype, fc, bw, name, nconnections=1, parent=None):
        """make(waterfall_sink_c_sptr self, int size, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> waterfall_sink_c_sptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_make(self, size, wintype, fc, bw, name, nconnections, parent)


    def exec_(self):
        """exec_(waterfall_sink_c_sptr self)"""
        return _qtgui_swig.waterfall_sink_c_sptr_exec_(self)


    def qwidget(self):
        """qwidget(waterfall_sink_c_sptr self) -> QWidget *"""
        return _qtgui_swig.waterfall_sink_c_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(waterfall_sink_c_sptr self) -> PyObject *"""
        return _qtgui_swig.waterfall_sink_c_sptr_pyqwidget(self)


    def clear_data(self):
        """clear_data(waterfall_sink_c_sptr self)"""
        return _qtgui_swig.waterfall_sink_c_sptr_clear_data(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(waterfall_sink_c_sptr self, int const fftsize)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(waterfall_sink_c_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_fft_size(self)


    def set_time_per_fft(self, t):
        """set_time_per_fft(waterfall_sink_c_sptr self, double const t)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_time_per_fft(self, t)


    def set_fft_average(self, fftavg):
        """set_fft_average(waterfall_sink_c_sptr self, float const fftavg)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_fft_average(self, fftavg)


    def fft_average(self):
        """fft_average(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_fft_average(self)


    def set_fft_window(self, win):
        """set_fft_window(waterfall_sink_c_sptr self, gr::filter::firdes::win_type const win)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_fft_window(self, win)


    def fft_window(self):
        """fft_window(waterfall_sink_c_sptr self) -> gr::filter::firdes::win_type"""
        return _qtgui_swig.waterfall_sink_c_sptr_fft_window(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(waterfall_sink_c_sptr self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_frequency_range(self, centerfreq, bandwidth)


    def set_intensity_range(self, min, max):
        """set_intensity_range(waterfall_sink_c_sptr self, double const min, double const max)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_intensity_range(self, min, max)


    def set_update_time(self, t):
        """set_update_time(waterfall_sink_c_sptr self, double t)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(waterfall_sink_c_sptr self, std::string const & title)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_title(self, title)


    def set_time_title(self, title):
        """set_time_title(waterfall_sink_c_sptr self, std::string const & title)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_time_title(self, title)


    def set_line_label(self, which, line):
        """set_line_label(waterfall_sink_c_sptr self, int which, std::string const & line)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_line_label(self, which, line)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(waterfall_sink_c_sptr self, int which, double alpha)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_line_alpha(self, which, alpha)


    def set_color_map(self, which, color):
        """set_color_map(waterfall_sink_c_sptr self, int which, int const color)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_color_map(self, which, color)


    def title(self):
        """title(waterfall_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_sptr_title(self)


    def line_label(self, which):
        """line_label(waterfall_sink_c_sptr self, int which) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_sptr_line_label(self, which)


    def line_alpha(self, which):
        """line_alpha(waterfall_sink_c_sptr self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_c_sptr_line_alpha(self, which)


    def color_map(self, which):
        """color_map(waterfall_sink_c_sptr self, int which) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_color_map(self, which)


    def set_size(self, width, height):
        """set_size(waterfall_sink_c_sptr self, int width, int height)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_size(self, width, height)


    def auto_scale(self):
        """auto_scale(waterfall_sink_c_sptr self)"""
        return _qtgui_swig.waterfall_sink_c_sptr_auto_scale(self)


    def min_intensity(self, which):
        """min_intensity(waterfall_sink_c_sptr self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_c_sptr_min_intensity(self, which)


    def max_intensity(self, which):
        """max_intensity(waterfall_sink_c_sptr self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_c_sptr_max_intensity(self, which)


    def enable_menu(self, en=True):
        """enable_menu(waterfall_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_c_sptr_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(waterfall_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_c_sptr_enable_grid(self, en)


    def disable_legend(self):
        """disable_legend(waterfall_sink_c_sptr self)"""
        return _qtgui_swig.waterfall_sink_c_sptr_disable_legend(self)

    d_qApplication = _swig_property(_qtgui_swig.waterfall_sink_c_sptr_d_qApplication_get, _qtgui_swig.waterfall_sink_c_sptr_d_qApplication_set)

    def history(self):
        """history(waterfall_sink_c_sptr self) -> unsigned int"""
        return _qtgui_swig.waterfall_sink_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(waterfall_sink_c_sptr self, int which, int delay)
        declare_sample_delay(waterfall_sink_c_sptr self, unsigned int delay)
        """
        return _qtgui_swig.waterfall_sink_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(waterfall_sink_c_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.waterfall_sink_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(waterfall_sink_c_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(waterfall_sink_c_sptr self) -> double"""
        return _qtgui_swig.waterfall_sink_c_sptr_relative_rate(self)


    def start(self):
        """start(waterfall_sink_c_sptr self) -> bool"""
        return _qtgui_swig.waterfall_sink_c_sptr_start(self)


    def stop(self):
        """stop(waterfall_sink_c_sptr self) -> bool"""
        return _qtgui_swig.waterfall_sink_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(waterfall_sink_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.waterfall_sink_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(waterfall_sink_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.waterfall_sink_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(waterfall_sink_c_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(waterfall_sink_c_sptr self, int m)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(waterfall_sink_c_sptr self)"""
        return _qtgui_swig.waterfall_sink_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(waterfall_sink_c_sptr self) -> bool"""
        return _qtgui_swig.waterfall_sink_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(waterfall_sink_c_sptr self, int m)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(waterfall_sink_c_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(waterfall_sink_c_sptr self, int i) -> long"""
        return _qtgui_swig.waterfall_sink_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(waterfall_sink_c_sptr self, long max_output_buffer)
        set_max_output_buffer(waterfall_sink_c_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.waterfall_sink_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(waterfall_sink_c_sptr self, int i) -> long"""
        return _qtgui_swig.waterfall_sink_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(waterfall_sink_c_sptr self, long min_output_buffer)
        set_min_output_buffer(waterfall_sink_c_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.waterfall_sink_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(waterfall_sink_c_sptr self, int which) -> float
        pc_input_buffers_full(waterfall_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(waterfall_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(waterfall_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(waterfall_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_var(waterfall_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(waterfall_sink_c_sptr self, int which) -> float
        pc_output_buffers_full(waterfall_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(waterfall_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(waterfall_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(waterfall_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_var(waterfall_sink_c_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(waterfall_sink_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(waterfall_sink_c_sptr self)"""
        return _qtgui_swig.waterfall_sink_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(waterfall_sink_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.waterfall_sink_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(waterfall_sink_c_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(waterfall_sink_c_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(waterfall_sink_c_sptr self, int priority) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(waterfall_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(waterfall_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(waterfall_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(waterfall_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(waterfall_sink_c_sptr self) -> long"""
        return _qtgui_swig.waterfall_sink_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(waterfall_sink_c_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(waterfall_sink_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.waterfall_sink_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(waterfall_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(waterfall_sink_c_sptr self, std::string name)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(waterfall_sink_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.waterfall_sink_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(waterfall_sink_c_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(waterfall_sink_c_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(waterfall_sink_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_message_subscribers(self, which_port)

waterfall_sink_c_sptr_swigregister = _qtgui_swig.waterfall_sink_c_sptr_swigregister
waterfall_sink_c_sptr_swigregister(waterfall_sink_c_sptr)


waterfall_sink_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
waterfall_sink_c = waterfall_sink_c.make;

class waterfall_sink_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::waterfall_sink_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::waterfall_sink_f)> self) -> waterfall_sink_f_sptr
        __init__(boost::shared_ptr<(gr::qtgui::waterfall_sink_f)> self, waterfall_sink_f p) -> waterfall_sink_f_sptr
        """
        this = _qtgui_swig.new_waterfall_sink_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(waterfall_sink_f_sptr self) -> waterfall_sink_f"""
        return _qtgui_swig.waterfall_sink_f_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_waterfall_sink_f_sptr
    __del__ = lambda self: None

    def make(self, size, wintype, fc, bw, name, nconnections=1, parent=None):
        """make(waterfall_sink_f_sptr self, int size, int wintype, double fc, double bw, std::string const & name, int nconnections=1, QWidget * parent=None) -> waterfall_sink_f_sptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_make(self, size, wintype, fc, bw, name, nconnections, parent)


    def exec_(self):
        """exec_(waterfall_sink_f_sptr self)"""
        return _qtgui_swig.waterfall_sink_f_sptr_exec_(self)


    def qwidget(self):
        """qwidget(waterfall_sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.waterfall_sink_f_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(waterfall_sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.waterfall_sink_f_sptr_pyqwidget(self)


    def clear_data(self):
        """clear_data(waterfall_sink_f_sptr self)"""
        return _qtgui_swig.waterfall_sink_f_sptr_clear_data(self)


    def set_fft_size(self, fftsize):
        """set_fft_size(waterfall_sink_f_sptr self, int const fftsize)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_fft_size(self, fftsize)


    def fft_size(self):
        """fft_size(waterfall_sink_f_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_fft_size(self)


    def set_time_per_fft(self, t):
        """set_time_per_fft(waterfall_sink_f_sptr self, double const t)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_time_per_fft(self, t)


    def set_fft_average(self, fftavg):
        """set_fft_average(waterfall_sink_f_sptr self, float const fftavg)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_fft_average(self, fftavg)


    def fft_average(self):
        """fft_average(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_fft_average(self)


    def set_fft_window(self, win):
        """set_fft_window(waterfall_sink_f_sptr self, gr::filter::firdes::win_type const win)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_fft_window(self, win)


    def fft_window(self):
        """fft_window(waterfall_sink_f_sptr self) -> gr::filter::firdes::win_type"""
        return _qtgui_swig.waterfall_sink_f_sptr_fft_window(self)


    def set_frequency_range(self, centerfreq, bandwidth):
        """set_frequency_range(waterfall_sink_f_sptr self, double const centerfreq, double const bandwidth)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_frequency_range(self, centerfreq, bandwidth)


    def set_intensity_range(self, min, max):
        """set_intensity_range(waterfall_sink_f_sptr self, double const min, double const max)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_intensity_range(self, min, max)


    def set_update_time(self, t):
        """set_update_time(waterfall_sink_f_sptr self, double t)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(waterfall_sink_f_sptr self, std::string const & title)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_title(self, title)


    def set_time_title(self, title):
        """set_time_title(waterfall_sink_f_sptr self, std::string const & title)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_time_title(self, title)


    def set_line_label(self, which, line):
        """set_line_label(waterfall_sink_f_sptr self, int which, std::string const & line)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_line_label(self, which, line)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(waterfall_sink_f_sptr self, int which, double alpha)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_line_alpha(self, which, alpha)


    def set_color_map(self, which, color):
        """set_color_map(waterfall_sink_f_sptr self, int which, int const color)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_color_map(self, which, color)


    def set_plot_pos_half(self, half):
        """set_plot_pos_half(waterfall_sink_f_sptr self, bool half)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_plot_pos_half(self, half)


    def title(self):
        """title(waterfall_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_sptr_title(self)


    def line_label(self, which):
        """line_label(waterfall_sink_f_sptr self, int which) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_sptr_line_label(self, which)


    def line_alpha(self, which):
        """line_alpha(waterfall_sink_f_sptr self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_f_sptr_line_alpha(self, which)


    def color_map(self, which):
        """color_map(waterfall_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_color_map(self, which)


    def set_size(self, width, height):
        """set_size(waterfall_sink_f_sptr self, int width, int height)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_size(self, width, height)


    def auto_scale(self):
        """auto_scale(waterfall_sink_f_sptr self)"""
        return _qtgui_swig.waterfall_sink_f_sptr_auto_scale(self)


    def min_intensity(self, which):
        """min_intensity(waterfall_sink_f_sptr self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_f_sptr_min_intensity(self, which)


    def max_intensity(self, which):
        """max_intensity(waterfall_sink_f_sptr self, int which) -> double"""
        return _qtgui_swig.waterfall_sink_f_sptr_max_intensity(self, which)


    def enable_menu(self, en=True):
        """enable_menu(waterfall_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_f_sptr_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(waterfall_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_f_sptr_enable_grid(self, en)


    def disable_legend(self):
        """disable_legend(waterfall_sink_f_sptr self)"""
        return _qtgui_swig.waterfall_sink_f_sptr_disable_legend(self)

    d_qApplication = _swig_property(_qtgui_swig.waterfall_sink_f_sptr_d_qApplication_get, _qtgui_swig.waterfall_sink_f_sptr_d_qApplication_set)

    def history(self):
        """history(waterfall_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.waterfall_sink_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(waterfall_sink_f_sptr self, int which, int delay)
        declare_sample_delay(waterfall_sink_f_sptr self, unsigned int delay)
        """
        return _qtgui_swig.waterfall_sink_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(waterfall_sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.waterfall_sink_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(waterfall_sink_f_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(waterfall_sink_f_sptr self) -> double"""
        return _qtgui_swig.waterfall_sink_f_sptr_relative_rate(self)


    def start(self):
        """start(waterfall_sink_f_sptr self) -> bool"""
        return _qtgui_swig.waterfall_sink_f_sptr_start(self)


    def stop(self):
        """stop(waterfall_sink_f_sptr self) -> bool"""
        return _qtgui_swig.waterfall_sink_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(waterfall_sink_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.waterfall_sink_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(waterfall_sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.waterfall_sink_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(waterfall_sink_f_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(waterfall_sink_f_sptr self, int m)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(waterfall_sink_f_sptr self)"""
        return _qtgui_swig.waterfall_sink_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(waterfall_sink_f_sptr self) -> bool"""
        return _qtgui_swig.waterfall_sink_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(waterfall_sink_f_sptr self, int m)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(waterfall_sink_f_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(waterfall_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.waterfall_sink_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(waterfall_sink_f_sptr self, long max_output_buffer)
        set_max_output_buffer(waterfall_sink_f_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.waterfall_sink_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(waterfall_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.waterfall_sink_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(waterfall_sink_f_sptr self, long min_output_buffer)
        set_min_output_buffer(waterfall_sink_f_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.waterfall_sink_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(waterfall_sink_f_sptr self, int which) -> float
        pc_input_buffers_full(waterfall_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(waterfall_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(waterfall_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(waterfall_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_var(waterfall_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(waterfall_sink_f_sptr self, int which) -> float
        pc_output_buffers_full(waterfall_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(waterfall_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(waterfall_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(waterfall_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_var(waterfall_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.waterfall_sink_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(waterfall_sink_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(waterfall_sink_f_sptr self)"""
        return _qtgui_swig.waterfall_sink_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(waterfall_sink_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.waterfall_sink_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(waterfall_sink_f_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(waterfall_sink_f_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(waterfall_sink_f_sptr self, int priority) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(waterfall_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(waterfall_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(waterfall_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(waterfall_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(waterfall_sink_f_sptr self) -> long"""
        return _qtgui_swig.waterfall_sink_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(waterfall_sink_f_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(waterfall_sink_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.waterfall_sink_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(waterfall_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(waterfall_sink_f_sptr self, std::string name)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(waterfall_sink_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.waterfall_sink_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(waterfall_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(waterfall_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(waterfall_sink_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_message_subscribers(self, which_port)

waterfall_sink_f_sptr_swigregister = _qtgui_swig.waterfall_sink_f_sptr_swigregister
waterfall_sink_f_sptr_swigregister(waterfall_sink_f_sptr)


waterfall_sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
waterfall_sink_f = waterfall_sink_f.make;

class histogram_sink_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::histogram_sink_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::histogram_sink_f)> self) -> histogram_sink_f_sptr
        __init__(boost::shared_ptr<(gr::qtgui::histogram_sink_f)> self, histogram_sink_f p) -> histogram_sink_f_sptr
        """
        this = _qtgui_swig.new_histogram_sink_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(histogram_sink_f_sptr self) -> histogram_sink_f"""
        return _qtgui_swig.histogram_sink_f_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_histogram_sink_f_sptr
    __del__ = lambda self: None

    def make(self, size, bins, xmin, xmax, name, nconnections=1, parent=None):
        """make(histogram_sink_f_sptr self, int size, int bins, double xmin, double xmax, std::string const & name, int nconnections=1, QWidget * parent=None) -> histogram_sink_f_sptr"""
        return _qtgui_swig.histogram_sink_f_sptr_make(self, size, bins, xmin, xmax, name, nconnections, parent)


    def exec_(self):
        """exec_(histogram_sink_f_sptr self)"""
        return _qtgui_swig.histogram_sink_f_sptr_exec_(self)


    def qwidget(self):
        """qwidget(histogram_sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.histogram_sink_f_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(histogram_sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.histogram_sink_f_sptr_pyqwidget(self)


    def title(self):
        """title(histogram_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_title(self)


    def line_label(self, which):
        """line_label(histogram_sink_f_sptr self, int which) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_line_label(self, which)


    def line_color(self, which):
        """line_color(histogram_sink_f_sptr self, int which) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_line_color(self, which)


    def line_width(self, which):
        """line_width(histogram_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_line_width(self, which)


    def line_style(self, which):
        """line_style(histogram_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_line_style(self, which)


    def line_marker(self, which):
        """line_marker(histogram_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(histogram_sink_f_sptr self, int which) -> double"""
        return _qtgui_swig.histogram_sink_f_sptr_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(histogram_sink_f_sptr self, int width, int height)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(histogram_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_sptr_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(histogram_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_sptr_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(histogram_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_sptr_enable_autoscale(self, en)


    def enable_semilogx(self, en=True):
        """enable_semilogx(histogram_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_sptr_enable_semilogx(self, en)


    def enable_semilogy(self, en=True):
        """enable_semilogy(histogram_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_sptr_enable_semilogy(self, en)


    def enable_accumulate(self, en=True):
        """enable_accumulate(histogram_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_sptr_enable_accumulate(self, en)


    def autoscalex(self):
        """autoscalex(histogram_sink_f_sptr self)"""
        return _qtgui_swig.histogram_sink_f_sptr_autoscalex(self)


    def nsamps(self):
        """nsamps(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_nsamps(self)


    def bins(self):
        """bins(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_bins(self)


    def reset(self):
        """reset(histogram_sink_f_sptr self)"""
        return _qtgui_swig.histogram_sink_f_sptr_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.histogram_sink_f_sptr_d_qApplication_get, _qtgui_swig.histogram_sink_f_sptr_d_qApplication_set)

    def set_y_axis(self, min, max):
        """set_y_axis(histogram_sink_f_sptr self, double min, double max)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_y_axis(self, min, max)


    def set_x_axis(self, min, max):
        """set_x_axis(histogram_sink_f_sptr self, double min, double max)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_x_axis(self, min, max)


    def set_update_time(self, t):
        """set_update_time(histogram_sink_f_sptr self, double t)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(histogram_sink_f_sptr self, std::string const & title)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_title(self, title)


    def set_line_label(self, which, line):
        """set_line_label(histogram_sink_f_sptr self, int which, std::string const & line)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_line_label(self, which, line)


    def set_line_color(self, which, color):
        """set_line_color(histogram_sink_f_sptr self, int which, std::string const & color)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(histogram_sink_f_sptr self, int which, int width)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(histogram_sink_f_sptr self, int which, int style)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(histogram_sink_f_sptr self, int which, int marker)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(histogram_sink_f_sptr self, int which, double alpha)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_line_alpha(self, which, alpha)


    def set_nsamps(self, newsize):
        """set_nsamps(histogram_sink_f_sptr self, int const newsize)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_nsamps(self, newsize)


    def set_bins(self, bins):
        """set_bins(histogram_sink_f_sptr self, int const bins)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_bins(self, bins)


    def disable_legend(self):
        """disable_legend(histogram_sink_f_sptr self)"""
        return _qtgui_swig.histogram_sink_f_sptr_disable_legend(self)


    def history(self):
        """history(histogram_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.histogram_sink_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(histogram_sink_f_sptr self, int which, int delay)
        declare_sample_delay(histogram_sink_f_sptr self, unsigned int delay)
        """
        return _qtgui_swig.histogram_sink_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(histogram_sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.histogram_sink_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(histogram_sink_f_sptr self) -> double"""
        return _qtgui_swig.histogram_sink_f_sptr_relative_rate(self)


    def start(self):
        """start(histogram_sink_f_sptr self) -> bool"""
        return _qtgui_swig.histogram_sink_f_sptr_start(self)


    def stop(self):
        """stop(histogram_sink_f_sptr self) -> bool"""
        return _qtgui_swig.histogram_sink_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(histogram_sink_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.histogram_sink_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(histogram_sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.histogram_sink_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(histogram_sink_f_sptr self, int m)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(histogram_sink_f_sptr self)"""
        return _qtgui_swig.histogram_sink_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(histogram_sink_f_sptr self) -> bool"""
        return _qtgui_swig.histogram_sink_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(histogram_sink_f_sptr self, int m)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(histogram_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.histogram_sink_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(histogram_sink_f_sptr self, long max_output_buffer)
        set_max_output_buffer(histogram_sink_f_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.histogram_sink_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(histogram_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.histogram_sink_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(histogram_sink_f_sptr self, long min_output_buffer)
        set_min_output_buffer(histogram_sink_f_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.histogram_sink_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(histogram_sink_f_sptr self, int which) -> float
        pc_input_buffers_full(histogram_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.histogram_sink_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(histogram_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(histogram_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.histogram_sink_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(histogram_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_var(histogram_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.histogram_sink_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(histogram_sink_f_sptr self, int which) -> float
        pc_output_buffers_full(histogram_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.histogram_sink_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(histogram_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(histogram_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.histogram_sink_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(histogram_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_var(histogram_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.histogram_sink_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(histogram_sink_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(histogram_sink_f_sptr self)"""
        return _qtgui_swig.histogram_sink_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(histogram_sink_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.histogram_sink_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(histogram_sink_f_sptr self, int priority) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(histogram_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(histogram_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(histogram_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.histogram_sink_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(histogram_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.histogram_sink_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(histogram_sink_f_sptr self) -> long"""
        return _qtgui_swig.histogram_sink_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(histogram_sink_f_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.histogram_sink_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(histogram_sink_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.histogram_sink_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(histogram_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(histogram_sink_f_sptr self, std::string name)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(histogram_sink_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.histogram_sink_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(histogram_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.histogram_sink_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(histogram_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.histogram_sink_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(histogram_sink_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.histogram_sink_f_sptr_message_subscribers(self, which_port)

histogram_sink_f_sptr_swigregister = _qtgui_swig.histogram_sink_f_sptr_swigregister
histogram_sink_f_sptr_swigregister(histogram_sink_f_sptr)


histogram_sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
histogram_sink_f = histogram_sink_f.make;

class number_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::number_sink)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::number_sink)> self) -> number_sink_sptr
        __init__(boost::shared_ptr<(gr::qtgui::number_sink)> self, number_sink p) -> number_sink_sptr
        """
        this = _qtgui_swig.new_number_sink_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(number_sink_sptr self) -> number_sink"""
        return _qtgui_swig.number_sink_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_number_sink_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(number_sink_sptr self, size_t itemsize, float average=0, gr::qtgui::graph_t graph_type, int nconnections=1, QWidget * parent=None) -> number_sink_sptr"""
        return _qtgui_swig.number_sink_sptr_make(self, *args, **kwargs)


    def exec_(self):
        """exec_(number_sink_sptr self)"""
        return _qtgui_swig.number_sink_sptr_exec_(self)


    def qwidget(self):
        """qwidget(number_sink_sptr self) -> QWidget *"""
        return _qtgui_swig.number_sink_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(number_sink_sptr self) -> PyObject *"""
        return _qtgui_swig.number_sink_sptr_pyqwidget(self)


    def set_update_time(self, t):
        """set_update_time(number_sink_sptr self, double t)"""
        return _qtgui_swig.number_sink_sptr_set_update_time(self, t)


    def set_average(self, avg):
        """set_average(number_sink_sptr self, float const avg)"""
        return _qtgui_swig.number_sink_sptr_set_average(self, avg)


    def set_graph_type(self, type):
        """set_graph_type(number_sink_sptr self, gr::qtgui::graph_t const type)"""
        return _qtgui_swig.number_sink_sptr_set_graph_type(self, type)


    def set_color(self, *args):
        """
        set_color(number_sink_sptr self, int which, std::string const & min, std::string const & max)
        set_color(number_sink_sptr self, int which, int min, int max)
        """
        return _qtgui_swig.number_sink_sptr_set_color(self, *args)


    def set_label(self, which, label):
        """set_label(number_sink_sptr self, int which, std::string const & label)"""
        return _qtgui_swig.number_sink_sptr_set_label(self, which, label)


    def set_min(self, which, min):
        """set_min(number_sink_sptr self, int which, float min)"""
        return _qtgui_swig.number_sink_sptr_set_min(self, which, min)


    def set_max(self, which, max):
        """set_max(number_sink_sptr self, int which, float max)"""
        return _qtgui_swig.number_sink_sptr_set_max(self, which, max)


    def set_title(self, title):
        """set_title(number_sink_sptr self, std::string const & title)"""
        return _qtgui_swig.number_sink_sptr_set_title(self, title)


    def set_unit(self, which, unit):
        """set_unit(number_sink_sptr self, int which, std::string const & unit)"""
        return _qtgui_swig.number_sink_sptr_set_unit(self, which, unit)


    def set_factor(self, which, factor):
        """set_factor(number_sink_sptr self, int which, float factor)"""
        return _qtgui_swig.number_sink_sptr_set_factor(self, which, factor)


    def average(self):
        """average(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_average(self)


    def graph_type(self):
        """graph_type(number_sink_sptr self) -> gr::qtgui::graph_t"""
        return _qtgui_swig.number_sink_sptr_graph_type(self)


    def color_min(self, which):
        """color_min(number_sink_sptr self, int which) -> std::string"""
        return _qtgui_swig.number_sink_sptr_color_min(self, which)


    def color_max(self, which):
        """color_max(number_sink_sptr self, int which) -> std::string"""
        return _qtgui_swig.number_sink_sptr_color_max(self, which)


    def label(self, which):
        """label(number_sink_sptr self, int which) -> std::string"""
        return _qtgui_swig.number_sink_sptr_label(self, which)


    def min(self, which):
        """min(number_sink_sptr self, int which) -> float"""
        return _qtgui_swig.number_sink_sptr_min(self, which)


    def max(self, which):
        """max(number_sink_sptr self, int which) -> float"""
        return _qtgui_swig.number_sink_sptr_max(self, which)


    def title(self):
        """title(number_sink_sptr self) -> std::string"""
        return _qtgui_swig.number_sink_sptr_title(self)


    def unit(self, which):
        """unit(number_sink_sptr self, int which) -> std::string"""
        return _qtgui_swig.number_sink_sptr_unit(self, which)


    def factor(self, which):
        """factor(number_sink_sptr self, int which) -> float"""
        return _qtgui_swig.number_sink_sptr_factor(self, which)


    def enable_menu(self, en=True):
        """enable_menu(number_sink_sptr self, bool en=True)"""
        return _qtgui_swig.number_sink_sptr_enable_menu(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(number_sink_sptr self, bool en=True)"""
        return _qtgui_swig.number_sink_sptr_enable_autoscale(self, en)


    def reset(self):
        """reset(number_sink_sptr self)"""
        return _qtgui_swig.number_sink_sptr_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.number_sink_sptr_d_qApplication_get, _qtgui_swig.number_sink_sptr_d_qApplication_set)

    def history(self):
        """history(number_sink_sptr self) -> unsigned int"""
        return _qtgui_swig.number_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(number_sink_sptr self, int which, int delay)
        declare_sample_delay(number_sink_sptr self, unsigned int delay)
        """
        return _qtgui_swig.number_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(number_sink_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.number_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(number_sink_sptr self) -> int"""
        return _qtgui_swig.number_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(number_sink_sptr self) -> double"""
        return _qtgui_swig.number_sink_sptr_relative_rate(self)


    def start(self):
        """start(number_sink_sptr self) -> bool"""
        return _qtgui_swig.number_sink_sptr_start(self)


    def stop(self):
        """stop(number_sink_sptr self) -> bool"""
        return _qtgui_swig.number_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(number_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.number_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(number_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.number_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(number_sink_sptr self) -> int"""
        return _qtgui_swig.number_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(number_sink_sptr self, int m)"""
        return _qtgui_swig.number_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(number_sink_sptr self)"""
        return _qtgui_swig.number_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(number_sink_sptr self) -> bool"""
        return _qtgui_swig.number_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(number_sink_sptr self, int m)"""
        return _qtgui_swig.number_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(number_sink_sptr self) -> int"""
        return _qtgui_swig.number_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(number_sink_sptr self, int i) -> long"""
        return _qtgui_swig.number_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(number_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(number_sink_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.number_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(number_sink_sptr self, int i) -> long"""
        return _qtgui_swig.number_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(number_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(number_sink_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.number_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(number_sink_sptr self, int which) -> float
        pc_input_buffers_full(number_sink_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.number_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(number_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(number_sink_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.number_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(number_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(number_sink_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.number_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(number_sink_sptr self, int which) -> float
        pc_output_buffers_full(number_sink_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.number_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(number_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(number_sink_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.number_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(number_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(number_sink_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.number_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(number_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.number_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(number_sink_sptr self)"""
        return _qtgui_swig.number_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(number_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.number_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(number_sink_sptr self) -> int"""
        return _qtgui_swig.number_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(number_sink_sptr self) -> int"""
        return _qtgui_swig.number_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(number_sink_sptr self, int priority) -> int"""
        return _qtgui_swig.number_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(number_sink_sptr self) -> std::string"""
        return _qtgui_swig.number_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(number_sink_sptr self) -> std::string"""
        return _qtgui_swig.number_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(number_sink_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.number_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(number_sink_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.number_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(number_sink_sptr self) -> long"""
        return _qtgui_swig.number_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(number_sink_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.number_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(number_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.number_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(number_sink_sptr self) -> std::string"""
        return _qtgui_swig.number_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(number_sink_sptr self, std::string name)"""
        return _qtgui_swig.number_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(number_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.number_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(number_sink_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.number_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(number_sink_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.number_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(number_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.number_sink_sptr_message_subscribers(self, which_port)

number_sink_sptr_swigregister = _qtgui_swig.number_sink_sptr_swigregister
number_sink_sptr_swigregister(number_sink_sptr)


number_sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
number_sink = number_sink.make;

class ber_sink_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::ber_sink_b)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::ber_sink_b)> self) -> ber_sink_b_sptr
        __init__(boost::shared_ptr<(gr::qtgui::ber_sink_b)> self, ber_sink_b p) -> ber_sink_b_sptr
        """
        this = _qtgui_swig.new_ber_sink_b_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(ber_sink_b_sptr self) -> ber_sink_b"""
        return _qtgui_swig.ber_sink_b_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_ber_sink_b_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(ber_sink_b_sptr self, pmt_vector_float esnos, int curves=1, int berminerrors=100, float berLimit=-7.0, std::vector< std::string,std::allocator< std::string > > curvenames, QWidget * parent=None) -> ber_sink_b_sptr"""
        return _qtgui_swig.ber_sink_b_sptr_make(self, *args, **kwargs)


    def exec_(self):
        """exec_(ber_sink_b_sptr self)"""
        return _qtgui_swig.ber_sink_b_sptr_exec_(self)


    def pyqwidget(self):
        """pyqwidget(ber_sink_b_sptr self) -> PyObject *"""
        return _qtgui_swig.ber_sink_b_sptr_pyqwidget(self)


    def set_y_axis(self, min, max):
        """set_y_axis(ber_sink_b_sptr self, double min, double max)"""
        return _qtgui_swig.ber_sink_b_sptr_set_y_axis(self, min, max)


    def set_x_axis(self, min, max):
        """set_x_axis(ber_sink_b_sptr self, double min, double max)"""
        return _qtgui_swig.ber_sink_b_sptr_set_x_axis(self, min, max)


    def set_update_time(self, t):
        """set_update_time(ber_sink_b_sptr self, double t)"""
        return _qtgui_swig.ber_sink_b_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(ber_sink_b_sptr self, std::string const & title)"""
        return _qtgui_swig.ber_sink_b_sptr_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(ber_sink_b_sptr self, int which, std::string const & label)"""
        return _qtgui_swig.ber_sink_b_sptr_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(ber_sink_b_sptr self, int which, std::string const & color)"""
        return _qtgui_swig.ber_sink_b_sptr_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(ber_sink_b_sptr self, int which, int width)"""
        return _qtgui_swig.ber_sink_b_sptr_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(ber_sink_b_sptr self, int which, int style)"""
        return _qtgui_swig.ber_sink_b_sptr_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(ber_sink_b_sptr self, int which, int marker)"""
        return _qtgui_swig.ber_sink_b_sptr_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(ber_sink_b_sptr self, int which, double alpha)"""
        return _qtgui_swig.ber_sink_b_sptr_set_line_alpha(self, which, alpha)


    def title(self):
        """title(ber_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_title(self)


    def line_label(self, which):
        """line_label(ber_sink_b_sptr self, int which) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_line_label(self, which)


    def line_color(self, which):
        """line_color(ber_sink_b_sptr self, int which) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_line_color(self, which)


    def line_width(self, which):
        """line_width(ber_sink_b_sptr self, int which) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_line_width(self, which)


    def line_style(self, which):
        """line_style(ber_sink_b_sptr self, int which) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_line_style(self, which)


    def line_marker(self, which):
        """line_marker(ber_sink_b_sptr self, int which) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(ber_sink_b_sptr self, int which) -> double"""
        return _qtgui_swig.ber_sink_b_sptr_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(ber_sink_b_sptr self, int width, int height)"""
        return _qtgui_swig.ber_sink_b_sptr_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(ber_sink_b_sptr self, bool en=True)"""
        return _qtgui_swig.ber_sink_b_sptr_enable_menu(self, en)


    def enable_autoscale(self, en):
        """enable_autoscale(ber_sink_b_sptr self, bool en)"""
        return _qtgui_swig.ber_sink_b_sptr_enable_autoscale(self, en)


    def nsamps(self):
        """nsamps(ber_sink_b_sptr self) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_nsamps(self)

    d_qApplication = _swig_property(_qtgui_swig.ber_sink_b_sptr_d_qApplication_get, _qtgui_swig.ber_sink_b_sptr_d_qApplication_set)

    def history(self):
        """history(ber_sink_b_sptr self) -> unsigned int"""
        return _qtgui_swig.ber_sink_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(ber_sink_b_sptr self, int which, int delay)
        declare_sample_delay(ber_sink_b_sptr self, unsigned int delay)
        """
        return _qtgui_swig.ber_sink_b_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(ber_sink_b_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.ber_sink_b_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(ber_sink_b_sptr self) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(ber_sink_b_sptr self) -> double"""
        return _qtgui_swig.ber_sink_b_sptr_relative_rate(self)


    def start(self):
        """start(ber_sink_b_sptr self) -> bool"""
        return _qtgui_swig.ber_sink_b_sptr_start(self)


    def stop(self):
        """stop(ber_sink_b_sptr self) -> bool"""
        return _qtgui_swig.ber_sink_b_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(ber_sink_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.ber_sink_b_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(ber_sink_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.ber_sink_b_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(ber_sink_b_sptr self) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(ber_sink_b_sptr self, int m)"""
        return _qtgui_swig.ber_sink_b_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(ber_sink_b_sptr self)"""
        return _qtgui_swig.ber_sink_b_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(ber_sink_b_sptr self) -> bool"""
        return _qtgui_swig.ber_sink_b_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(ber_sink_b_sptr self, int m)"""
        return _qtgui_swig.ber_sink_b_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(ber_sink_b_sptr self) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(ber_sink_b_sptr self, int i) -> long"""
        return _qtgui_swig.ber_sink_b_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(ber_sink_b_sptr self, long max_output_buffer)
        set_max_output_buffer(ber_sink_b_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.ber_sink_b_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(ber_sink_b_sptr self, int i) -> long"""
        return _qtgui_swig.ber_sink_b_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(ber_sink_b_sptr self, long min_output_buffer)
        set_min_output_buffer(ber_sink_b_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.ber_sink_b_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(ber_sink_b_sptr self, int which) -> float
        pc_input_buffers_full(ber_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.ber_sink_b_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(ber_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(ber_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.ber_sink_b_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(ber_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_var(ber_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.ber_sink_b_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(ber_sink_b_sptr self, int which) -> float
        pc_output_buffers_full(ber_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.ber_sink_b_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(ber_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(ber_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.ber_sink_b_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(ber_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_var(ber_sink_b_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.ber_sink_b_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(ber_sink_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.ber_sink_b_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(ber_sink_b_sptr self)"""
        return _qtgui_swig.ber_sink_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(ber_sink_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.ber_sink_b_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(ber_sink_b_sptr self) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(ber_sink_b_sptr self) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(ber_sink_b_sptr self, int priority) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(ber_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_name(self)


    def symbol_name(self):
        """symbol_name(ber_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(ber_sink_b_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.ber_sink_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(ber_sink_b_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.ber_sink_b_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(ber_sink_b_sptr self) -> long"""
        return _qtgui_swig.ber_sink_b_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(ber_sink_b_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.ber_sink_b_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(ber_sink_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.ber_sink_b_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(ber_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(ber_sink_b_sptr self, std::string name)"""
        return _qtgui_swig.ber_sink_b_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(ber_sink_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.ber_sink_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(ber_sink_b_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.ber_sink_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(ber_sink_b_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.ber_sink_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(ber_sink_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.ber_sink_b_sptr_message_subscribers(self, which_port)

ber_sink_b_sptr_swigregister = _qtgui_swig.ber_sink_b_sptr_swigregister
ber_sink_b_sptr_swigregister(ber_sink_b_sptr)


ber_sink_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
ber_sink_b = ber_sink_b.make;

class vector_sink_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::qtgui::vector_sink_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::qtgui::vector_sink_f)> self) -> vector_sink_f_sptr
        __init__(boost::shared_ptr<(gr::qtgui::vector_sink_f)> self, vector_sink_f p) -> vector_sink_f_sptr
        """
        this = _qtgui_swig.new_vector_sink_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_sink_f_sptr self) -> vector_sink_f"""
        return _qtgui_swig.vector_sink_f_sptr___deref__(self)

    __swig_destroy__ = _qtgui_swig.delete_vector_sink_f_sptr
    __del__ = lambda self: None

    def make(self, vlen, x_start, x_step, x_axis_label, y_axis_label, name, nconnections=1, parent=None):
        """make(vector_sink_f_sptr self, int vlen, double x_start, double x_step, std::string const & x_axis_label, std::string const & y_axis_label, std::string const & name, int nconnections=1, QWidget * parent=None) -> vector_sink_f_sptr"""
        return _qtgui_swig.vector_sink_f_sptr_make(self, vlen, x_start, x_step, x_axis_label, y_axis_label, name, nconnections, parent)


    def exec_(self):
        """exec_(vector_sink_f_sptr self)"""
        return _qtgui_swig.vector_sink_f_sptr_exec_(self)


    def qwidget(self):
        """qwidget(vector_sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.vector_sink_f_sptr_qwidget(self)


    def pyqwidget(self):
        """pyqwidget(vector_sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.vector_sink_f_sptr_pyqwidget(self)


    def vlen(self):
        """vlen(vector_sink_f_sptr self) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_vlen(self)


    def set_vec_average(self, avg):
        """set_vec_average(vector_sink_f_sptr self, float const avg)"""
        return _qtgui_swig.vector_sink_f_sptr_set_vec_average(self, avg)


    def vec_average(self):
        """vec_average(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_vec_average(self)


    def set_x_axis(self, start, step):
        """set_x_axis(vector_sink_f_sptr self, double const start, double const step)"""
        return _qtgui_swig.vector_sink_f_sptr_set_x_axis(self, start, step)


    def set_y_axis(self, min, max):
        """set_y_axis(vector_sink_f_sptr self, double min, double max)"""
        return _qtgui_swig.vector_sink_f_sptr_set_y_axis(self, min, max)


    def set_ref_level(self, ref_level):
        """set_ref_level(vector_sink_f_sptr self, double ref_level)"""
        return _qtgui_swig.vector_sink_f_sptr_set_ref_level(self, ref_level)


    def set_x_axis_label(self, label):
        """set_x_axis_label(vector_sink_f_sptr self, std::string const & label)"""
        return _qtgui_swig.vector_sink_f_sptr_set_x_axis_label(self, label)


    def set_y_axis_label(self, label):
        """set_y_axis_label(vector_sink_f_sptr self, std::string const & label)"""
        return _qtgui_swig.vector_sink_f_sptr_set_y_axis_label(self, label)


    def set_x_axis_units(self, units):
        """set_x_axis_units(vector_sink_f_sptr self, std::string const & units)"""
        return _qtgui_swig.vector_sink_f_sptr_set_x_axis_units(self, units)


    def set_y_axis_units(self, units):
        """set_y_axis_units(vector_sink_f_sptr self, std::string const & units)"""
        return _qtgui_swig.vector_sink_f_sptr_set_y_axis_units(self, units)


    def set_update_time(self, t):
        """set_update_time(vector_sink_f_sptr self, double t)"""
        return _qtgui_swig.vector_sink_f_sptr_set_update_time(self, t)


    def set_title(self, title):
        """set_title(vector_sink_f_sptr self, std::string const & title)"""
        return _qtgui_swig.vector_sink_f_sptr_set_title(self, title)


    def set_line_label(self, which, label):
        """set_line_label(vector_sink_f_sptr self, int which, std::string const & label)"""
        return _qtgui_swig.vector_sink_f_sptr_set_line_label(self, which, label)


    def set_line_color(self, which, color):
        """set_line_color(vector_sink_f_sptr self, int which, std::string const & color)"""
        return _qtgui_swig.vector_sink_f_sptr_set_line_color(self, which, color)


    def set_line_width(self, which, width):
        """set_line_width(vector_sink_f_sptr self, int which, int width)"""
        return _qtgui_swig.vector_sink_f_sptr_set_line_width(self, which, width)


    def set_line_style(self, which, style):
        """set_line_style(vector_sink_f_sptr self, int which, int style)"""
        return _qtgui_swig.vector_sink_f_sptr_set_line_style(self, which, style)


    def set_line_marker(self, which, marker):
        """set_line_marker(vector_sink_f_sptr self, int which, int marker)"""
        return _qtgui_swig.vector_sink_f_sptr_set_line_marker(self, which, marker)


    def set_line_alpha(self, which, alpha):
        """set_line_alpha(vector_sink_f_sptr self, int which, double alpha)"""
        return _qtgui_swig.vector_sink_f_sptr_set_line_alpha(self, which, alpha)


    def title(self):
        """title(vector_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_title(self)


    def line_label(self, which):
        """line_label(vector_sink_f_sptr self, int which) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_line_label(self, which)


    def line_color(self, which):
        """line_color(vector_sink_f_sptr self, int which) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_line_color(self, which)


    def line_width(self, which):
        """line_width(vector_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_line_width(self, which)


    def line_style(self, which):
        """line_style(vector_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_line_style(self, which)


    def line_marker(self, which):
        """line_marker(vector_sink_f_sptr self, int which) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_line_marker(self, which)


    def line_alpha(self, which):
        """line_alpha(vector_sink_f_sptr self, int which) -> double"""
        return _qtgui_swig.vector_sink_f_sptr_line_alpha(self, which)


    def set_size(self, width, height):
        """set_size(vector_sink_f_sptr self, int width, int height)"""
        return _qtgui_swig.vector_sink_f_sptr_set_size(self, width, height)


    def enable_menu(self, en=True):
        """enable_menu(vector_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.vector_sink_f_sptr_enable_menu(self, en)


    def enable_grid(self, en=True):
        """enable_grid(vector_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.vector_sink_f_sptr_enable_grid(self, en)


    def enable_autoscale(self, en=True):
        """enable_autoscale(vector_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.vector_sink_f_sptr_enable_autoscale(self, en)


    def clear_max_hold(self):
        """clear_max_hold(vector_sink_f_sptr self)"""
        return _qtgui_swig.vector_sink_f_sptr_clear_max_hold(self)


    def clear_min_hold(self):
        """clear_min_hold(vector_sink_f_sptr self)"""
        return _qtgui_swig.vector_sink_f_sptr_clear_min_hold(self)


    def reset(self):
        """reset(vector_sink_f_sptr self)"""
        return _qtgui_swig.vector_sink_f_sptr_reset(self)

    d_qApplication = _swig_property(_qtgui_swig.vector_sink_f_sptr_d_qApplication_get, _qtgui_swig.vector_sink_f_sptr_d_qApplication_set)

    def history(self):
        """history(vector_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.vector_sink_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_sink_f_sptr self, int which, int delay)
        declare_sample_delay(vector_sink_f_sptr self, unsigned int delay)
        """
        return _qtgui_swig.vector_sink_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.vector_sink_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_sink_f_sptr self) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_sink_f_sptr self) -> double"""
        return _qtgui_swig.vector_sink_f_sptr_relative_rate(self)


    def start(self):
        """start(vector_sink_f_sptr self) -> bool"""
        return _qtgui_swig.vector_sink_f_sptr_start(self)


    def stop(self):
        """stop(vector_sink_f_sptr self) -> bool"""
        return _qtgui_swig.vector_sink_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_sink_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.vector_sink_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.vector_sink_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_sink_f_sptr self) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_sink_f_sptr self, int m)"""
        return _qtgui_swig.vector_sink_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_sink_f_sptr self)"""
        return _qtgui_swig.vector_sink_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_sink_f_sptr self) -> bool"""
        return _qtgui_swig.vector_sink_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_sink_f_sptr self, int m)"""
        return _qtgui_swig.vector_sink_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_sink_f_sptr self) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.vector_sink_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_sink_f_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_sink_f_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.vector_sink_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_sink_f_sptr self, int i) -> long"""
        return _qtgui_swig.vector_sink_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_sink_f_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_sink_f_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.vector_sink_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.vector_sink_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.vector_sink_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.vector_sink_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.vector_sink_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.vector_sink_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.vector_sink_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_sink_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.vector_sink_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_sink_f_sptr self)"""
        return _qtgui_swig.vector_sink_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_sink_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.vector_sink_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_sink_f_sptr self) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_sink_f_sptr self) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_sink_f_sptr self, int priority) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.vector_sink_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.vector_sink_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_sink_f_sptr self) -> long"""
        return _qtgui_swig.vector_sink_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_sink_f_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.vector_sink_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_sink_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.vector_sink_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_sink_f_sptr self, std::string name)"""
        return _qtgui_swig.vector_sink_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_sink_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _qtgui_swig.vector_sink_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.vector_sink_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_sink_f_sptr self) -> swig_int_ptr"""
        return _qtgui_swig.vector_sink_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_sink_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _qtgui_swig.vector_sink_f_sptr_message_subscribers(self, which_port)

vector_sink_f_sptr_swigregister = _qtgui_swig.vector_sink_f_sptr_swigregister
vector_sink_f_sptr_swigregister(vector_sink_f_sptr)


vector_sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_sink_f = vector_sink_f.make;



