# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.1
#
# 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 as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _qtgui_swig
else:
    import _qtgui_swig

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)



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

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

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

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

NUM_GRAPH_HORIZ = _qtgui_swig.NUM_GRAPH_HORIZ

NUM_GRAPH_VERT = _qtgui_swig.NUM_GRAPH_VERT

INT = _qtgui_swig.INT

FLOAT = _qtgui_swig.FLOAT

DOUBLE = _qtgui_swig.DOUBLE

COMPLEX = _qtgui_swig.COMPLEX

STRING = _qtgui_swig.STRING

INT_VEC = _qtgui_swig.INT_VEC

FLOAT_VEC = _qtgui_swig.FLOAT_VEC

DOUBLE_VEC = _qtgui_swig.DOUBLE_VEC

COMPLEX_VEC = _qtgui_swig.COMPLEX_VEC

INTENSITY_COLOR_MAP_TYPE_MULTI_COLOR = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_MULTI_COLOR

INTENSITY_COLOR_MAP_TYPE_WHITE_HOT = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_WHITE_HOT

INTENSITY_COLOR_MAP_TYPE_BLACK_HOT = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_BLACK_HOT

INTENSITY_COLOR_MAP_TYPE_INCANDESCENT = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_INCANDESCENT

INTENSITY_COLOR_MAP_TYPE_USER_DEFINED = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_USER_DEFINED

INTENSITY_COLOR_MAP_TYPE_SUNSET = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_SUNSET

INTENSITY_COLOR_MAP_TYPE_COOL = _qtgui_swig.INTENSITY_COLOR_MAP_TYPE_COOL

TRIG_MODE_FREE = _qtgui_swig.TRIG_MODE_FREE

TRIG_MODE_AUTO = _qtgui_swig.TRIG_MODE_AUTO

TRIG_MODE_NORM = _qtgui_swig.TRIG_MODE_NORM

TRIG_MODE_TAG = _qtgui_swig.TRIG_MODE_TAG

TRIG_SLOPE_POS = _qtgui_swig.TRIG_SLOPE_POS

TRIG_SLOPE_NEG = _qtgui_swig.TRIG_SLOPE_NEG

class sink_c(object):
    r"""Proxy of C++ gr::qtgui::sink_c class."""

    thisown = 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

    @staticmethod
    def make(fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", plotfreq: "bool", plotwaterfall: "bool", plottime: "bool", plotconst: "bool", parent: "QWidget *"=None) -> "gr::qtgui::sink_c::sptr":
        r"""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)

    def exec_(self) -> "void":
        r"""exec_(sink_c self)"""
        return _qtgui_swig.sink_c_exec_(self)

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

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

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

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

    def set_frequency_range(self, centerfreq: "double const", bandwidth: "double const") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "bool") -> "void":
        r"""enable_rf_freq(sink_c self, bool en)"""
        return _qtgui_swig.sink_c_enable_rf_freq(self, en)

    def set_update_time(self, t: "double") -> "void":
        r"""set_update_time(sink_c self, double t)"""
        return _qtgui_swig.sink_c_set_update_time(self, t)
    d_qApplication = property(_qtgui_swig.sink_c_d_qApplication_get, _qtgui_swig.sink_c_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_sink_c

# Register sink_c in _qtgui_swig:
_qtgui_swig.sink_c_swigregister(sink_c)

def sink_c_make(fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", plotfreq: "bool", plotwaterfall: "bool", plottime: "bool", plotconst: "bool", parent: "QWidget *"=None) -> "gr::qtgui::sink_c::sptr":
    r"""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):
    r"""Proxy of C++ gr::qtgui::sink_f class."""

    thisown = 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

    @staticmethod
    def make(fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", plotfreq: "bool", plotwaterfall: "bool", plottime: "bool", plotconst: "bool", parent: "QWidget *"=None) -> "gr::qtgui::sink_f::sptr":
        r"""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)

    def exec_(self) -> "void":
        r"""exec_(sink_f self)"""
        return _qtgui_swig.sink_f_exec_(self)

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

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

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

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

    def set_frequency_range(self, centerfreq: "double const", bandwidth: "double const") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "bool") -> "void":
        r"""enable_rf_freq(sink_f self, bool en)"""
        return _qtgui_swig.sink_f_enable_rf_freq(self, en)

    def set_update_time(self, t: "double") -> "void":
        r"""set_update_time(sink_f self, double t)"""
        return _qtgui_swig.sink_f_set_update_time(self, t)
    d_qApplication = property(_qtgui_swig.sink_f_d_qApplication_get, _qtgui_swig.sink_f_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_sink_f

# Register sink_f in _qtgui_swig:
_qtgui_swig.sink_f_swigregister(sink_f)

def sink_f_make(fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", plotfreq: "bool", plotwaterfall: "bool", plottime: "bool", plotconst: "bool", parent: "QWidget *"=None) -> "gr::qtgui::sink_f::sptr":
    r"""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):
    r"""Proxy of C++ gr::qtgui::time_sink_c class."""

    thisown = 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

    @staticmethod
    def make(size: "int", samp_rate: "double", name: "std::string const &", nconnections: "unsigned int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_sink_c::sptr":
        r"""make(int size, double samp_rate, std::string const & name, unsigned int nconnections=1, QWidget * parent=None) -> time_sink_c_sptr"""
        return _qtgui_swig.time_sink_c_make(size, samp_rate, name, nconnections, parent)

    def exec_(self) -> "void":
        r"""exec_(time_sink_c self)"""
        return _qtgui_swig.time_sink_c_exec_(self)

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

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

    def set_y_axis(self, min: "double", max: "double") -> "void":
        r"""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) -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", label: "std::string const &") -> "void":
        r"""set_line_label(time_sink_c self, unsigned int which, std::string const & label)"""
        return _qtgui_swig.time_sink_c_set_line_label(self, which, label)

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

    def set_line_width(self, which: "unsigned int", width: "int") -> "void":
        r"""set_line_width(time_sink_c self, unsigned int which, int width)"""
        return _qtgui_swig.time_sink_c_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(time_sink_c self, unsigned int which, int style)"""
        return _qtgui_swig.time_sink_c_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(time_sink_c self, unsigned int which, int marker)"""
        return _qtgui_swig.time_sink_c_set_line_marker(self, which, marker)

    def set_nsamps(self, newsize: "int const") -> "void":
        r"""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: "double const") -> "void":
        r"""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: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(time_sink_c self, unsigned int which, double alpha)"""
        return _qtgui_swig.time_sink_c_set_line_alpha(self, which, alpha)

    def set_trigger_mode(self, *args, **kwargs) -> "void":
        r"""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) -> "std::string":
        r"""title(time_sink_c self) -> std::string"""
        return _qtgui_swig.time_sink_c_title(self)

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""enable_menu(time_sink_c self, bool en=True)"""
        return _qtgui_swig.time_sink_c_enable_menu(self, en)

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

    def enable_autoscale(self, en: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""enable_semilogx(time_sink_c self, bool en=True)"""
        return _qtgui_swig.time_sink_c_enable_semilogx(self, en)

    def enable_semilogy(self, en: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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, *args) -> "void":
        r"""
        enable_tags(time_sink_c self, unsigned int which, bool en)
        enable_tags(time_sink_c self, bool en)
        """
        return _qtgui_swig.time_sink_c_enable_tags(self, *args)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(time_sink_c self, bool en=True)"""
        return _qtgui_swig.time_sink_c_enable_axis_labels(self, en)

    def disable_legend(self) -> "void":
        r"""disable_legend(time_sink_c self)"""
        return _qtgui_swig.time_sink_c_disable_legend(self)

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

    def reset(self) -> "void":
        r"""reset(time_sink_c self)"""
        return _qtgui_swig.time_sink_c_reset(self)
    d_qApplication = property(_qtgui_swig.time_sink_c_d_qApplication_get, _qtgui_swig.time_sink_c_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_time_sink_c

# Register time_sink_c in _qtgui_swig:
_qtgui_swig.time_sink_c_swigregister(time_sink_c)

def time_sink_c_make(size: "int", samp_rate: "double", name: "std::string const &", nconnections: "unsigned int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_sink_c::sptr":
    r"""time_sink_c_make(int size, double samp_rate, std::string const & name, unsigned 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):
    r"""Proxy of C++ gr::qtgui::time_sink_f class."""

    thisown = 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

    @staticmethod
    def make(size: "int", samp_rate: "double", name: "std::string const &", nconnections: "unsigned int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_sink_f::sptr":
        r"""make(int size, double samp_rate, std::string const & name, unsigned int nconnections=1, QWidget * parent=None) -> time_sink_f_sptr"""
        return _qtgui_swig.time_sink_f_make(size, samp_rate, name, nconnections, parent)

    def exec_(self) -> "void":
        r"""exec_(time_sink_f self)"""
        return _qtgui_swig.time_sink_f_exec_(self)

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

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

    def set_y_axis(self, min: "double", max: "double") -> "void":
        r"""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) -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", line: "std::string const &") -> "void":
        r"""set_line_label(time_sink_f self, unsigned int which, std::string const & line)"""
        return _qtgui_swig.time_sink_f_set_line_label(self, which, line)

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

    def set_line_width(self, which: "unsigned int", width: "int") -> "void":
        r"""set_line_width(time_sink_f self, unsigned int which, int width)"""
        return _qtgui_swig.time_sink_f_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(time_sink_f self, unsigned int which, int style)"""
        return _qtgui_swig.time_sink_f_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(time_sink_f self, unsigned int which, int marker)"""
        return _qtgui_swig.time_sink_f_set_line_marker(self, which, marker)

    def set_nsamps(self, newsize: "int const") -> "void":
        r"""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: "double const") -> "void":
        r"""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: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(time_sink_f self, unsigned int which, double alpha)"""
        return _qtgui_swig.time_sink_f_set_line_alpha(self, which, alpha)

    def set_trigger_mode(self, *args, **kwargs) -> "void":
        r"""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) -> "std::string":
        r"""title(time_sink_f self) -> std::string"""
        return _qtgui_swig.time_sink_f_title(self)

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""enable_menu(time_sink_f self, bool en=True)"""
        return _qtgui_swig.time_sink_f_enable_menu(self, en)

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

    def enable_autoscale(self, en: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""enable_semilogx(time_sink_f self, bool en=True)"""
        return _qtgui_swig.time_sink_f_enable_semilogx(self, en)

    def enable_semilogy(self, en: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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, *args) -> "void":
        r"""
        enable_tags(time_sink_f self, unsigned int which, bool en)
        enable_tags(time_sink_f self, bool en)
        """
        return _qtgui_swig.time_sink_f_enable_tags(self, *args)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(time_sink_f self, bool en=True)"""
        return _qtgui_swig.time_sink_f_enable_axis_labels(self, en)

    def disable_legend(self) -> "void":
        r"""disable_legend(time_sink_f self)"""
        return _qtgui_swig.time_sink_f_disable_legend(self)

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

    def reset(self) -> "void":
        r"""reset(time_sink_f self)"""
        return _qtgui_swig.time_sink_f_reset(self)
    d_qApplication = property(_qtgui_swig.time_sink_f_d_qApplication_get, _qtgui_swig.time_sink_f_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_time_sink_f

# Register time_sink_f in _qtgui_swig:
_qtgui_swig.time_sink_f_swigregister(time_sink_f)

def time_sink_f_make(size: "int", samp_rate: "double", name: "std::string const &", nconnections: "unsigned int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_sink_f::sptr":
    r"""time_sink_f_make(int size, double samp_rate, std::string const & name, unsigned 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):
    r"""Proxy of C++ gr::qtgui::time_raster_sink_b class."""

    thisown = 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

    @staticmethod
    def make(samp_rate: "double", rows: "double", cols: "double", mult: "pmt_vector_float", offset: "pmt_vector_float", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_raster_sink_b::sptr":
        r"""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)

    def exec_(self) -> "void":
        r"""exec_(time_raster_sink_b self)"""
        return _qtgui_swig.time_raster_sink_b_exec_(self)

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

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

    def set_update_time(self, t: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", lable: "std::string const &") -> "void":
        r"""set_line_label(time_raster_sink_b self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(time_raster_sink_b self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(time_raster_sink_b self, unsigned int which, int width)"""
        return _qtgui_swig.time_raster_sink_b_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "Qt::PenStyle") -> "void":
        r"""set_line_style(time_raster_sink_b self, unsigned int which, Qt::PenStyle style)"""
        return _qtgui_swig.time_raster_sink_b_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "QwtSymbol::Style") -> "void":
        r"""set_line_marker(time_raster_sink_b self, unsigned int which, QwtSymbol::Style marker)"""
        return _qtgui_swig.time_raster_sink_b_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(time_raster_sink_b self, unsigned int which, double alpha)"""
        return _qtgui_swig.time_raster_sink_b_set_line_alpha(self, which, alpha)

    def set_color_map(self, which: "unsigned int", color: "int const") -> "void":
        r"""set_color_map(time_raster_sink_b self, unsigned int which, int const color)"""
        return _qtgui_swig.time_raster_sink_b_set_color_map(self, which, color)

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

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

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "double const") -> "void":
        r"""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: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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) -> "double":
        r"""num_rows(time_raster_sink_b self) -> double"""
        return _qtgui_swig.time_raster_sink_b_num_rows(self)

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

    def set_multiplier(self, mult: "pmt_vector_float") -> "void":
        r"""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: "pmt_vector_float") -> "void":
        r"""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: "float", max: "float") -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""enable_autoscale(time_raster_sink_b self, bool en)"""
        return _qtgui_swig.time_raster_sink_b_enable_autoscale(self, en)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(time_raster_sink_b self, bool en=True)"""
        return _qtgui_swig.time_raster_sink_b_enable_axis_labels(self, en)

    def reset(self) -> "void":
        r"""reset(time_raster_sink_b self)"""
        return _qtgui_swig.time_raster_sink_b_reset(self)
    d_qApplication = property(_qtgui_swig.time_raster_sink_b_d_qApplication_get, _qtgui_swig.time_raster_sink_b_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_time_raster_sink_b

# Register time_raster_sink_b in _qtgui_swig:
_qtgui_swig.time_raster_sink_b_swigregister(time_raster_sink_b)

def time_raster_sink_b_make(samp_rate: "double", rows: "double", cols: "double", mult: "pmt_vector_float", offset: "pmt_vector_float", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_raster_sink_b::sptr":
    r"""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):
    r"""Proxy of C++ gr::qtgui::time_raster_sink_f class."""

    thisown = 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

    @staticmethod
    def make(samp_rate: "double", rows: "double", cols: "double", mult: "pmt_vector_float", offset: "pmt_vector_float", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_raster_sink_f::sptr":
        r"""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)

    def exec_(self) -> "void":
        r"""exec_(time_raster_sink_f self)"""
        return _qtgui_swig.time_raster_sink_f_exec_(self)

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

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

    def set_update_time(self, t: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", lable: "std::string const &") -> "void":
        r"""set_line_label(time_raster_sink_f self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(time_raster_sink_f self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(time_raster_sink_f self, unsigned int which, int width)"""
        return _qtgui_swig.time_raster_sink_f_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "Qt::PenStyle") -> "void":
        r"""set_line_style(time_raster_sink_f self, unsigned int which, Qt::PenStyle style)"""
        return _qtgui_swig.time_raster_sink_f_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "QwtSymbol::Style") -> "void":
        r"""set_line_marker(time_raster_sink_f self, unsigned int which, QwtSymbol::Style marker)"""
        return _qtgui_swig.time_raster_sink_f_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(time_raster_sink_f self, unsigned int which, double alpha)"""
        return _qtgui_swig.time_raster_sink_f_set_line_alpha(self, which, alpha)

    def set_color_map(self, which: "unsigned int", color: "int const") -> "void":
        r"""set_color_map(time_raster_sink_f self, unsigned int which, int const color)"""
        return _qtgui_swig.time_raster_sink_f_set_color_map(self, which, color)

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

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

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "double const") -> "void":
        r"""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: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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) -> "double":
        r"""num_rows(time_raster_sink_f self) -> double"""
        return _qtgui_swig.time_raster_sink_f_num_rows(self)

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

    def set_multiplier(self, mult: "pmt_vector_float") -> "void":
        r"""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: "pmt_vector_float") -> "void":
        r"""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: "float", max: "float") -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""enable_autoscale(time_raster_sink_f self, bool en)"""
        return _qtgui_swig.time_raster_sink_f_enable_autoscale(self, en)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(time_raster_sink_f self, bool en=True)"""
        return _qtgui_swig.time_raster_sink_f_enable_axis_labels(self, en)

    def reset(self) -> "void":
        r"""reset(time_raster_sink_f self)"""
        return _qtgui_swig.time_raster_sink_f_reset(self)
    d_qApplication = property(_qtgui_swig.time_raster_sink_f_d_qApplication_get, _qtgui_swig.time_raster_sink_f_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_time_raster_sink_f

# Register time_raster_sink_f in _qtgui_swig:
_qtgui_swig.time_raster_sink_f_swigregister(time_raster_sink_f)

def time_raster_sink_f_make(samp_rate: "double", rows: "double", cols: "double", mult: "pmt_vector_float", offset: "pmt_vector_float", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_raster_sink_f::sptr":
    r"""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):
    r"""Proxy of C++ gr::qtgui::freq_sink_c class."""

    thisown = 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

    @staticmethod
    def make(fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::freq_sink_c::sptr":
        r"""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)

    def exec_(self) -> "void":
        r"""exec_(freq_sink_c self)"""
        return _qtgui_swig.freq_sink_c_exec_(self)

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

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

    def set_fft_size(self, fftsize: "int const") -> "void":
        r"""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) -> "int":
        r"""fft_size(freq_sink_c self) -> int"""
        return _qtgui_swig.freq_sink_c_fft_size(self)

    def set_fft_average(self, fftavg: "float const") -> "void":
        r"""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) -> "float":
        r"""fft_average(freq_sink_c self) -> float"""
        return _qtgui_swig.freq_sink_c_fft_average(self)

    def set_fft_window(self, win: "gr::filter::firdes::win_type const") -> "void":
        r"""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) -> "gr::filter::firdes::win_type":
        r"""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: "double const", bandwidth: "double const") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""set_title(freq_sink_c self, std::string const & title)"""
        return _qtgui_swig.freq_sink_c_set_title(self, title)

    def set_y_label(self, label: "std::string const &", unit: "std::string const &") -> "void":
        r"""set_y_label(freq_sink_c self, std::string const & label, std::string const & unit)"""
        return _qtgui_swig.freq_sink_c_set_y_label(self, label, unit)

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

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

    def set_line_width(self, which: "unsigned int", width: "int") -> "void":
        r"""set_line_width(freq_sink_c self, unsigned int which, int width)"""
        return _qtgui_swig.freq_sink_c_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(freq_sink_c self, unsigned int which, int style)"""
        return _qtgui_swig.freq_sink_c_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(freq_sink_c self, unsigned int which, int marker)"""
        return _qtgui_swig.freq_sink_c_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(freq_sink_c self, unsigned int which, double alpha)"""
        return _qtgui_swig.freq_sink_c_set_line_alpha(self, which, alpha)

    def set_trigger_mode(self, *args, **kwargs) -> "void":
        r"""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) -> "std::string":
        r"""title(freq_sink_c self) -> std::string"""
        return _qtgui_swig.freq_sink_c_title(self)

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""enable_menu(freq_sink_c self, bool en=True)"""
        return _qtgui_swig.freq_sink_c_enable_menu(self, en)

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

    def enable_autoscale(self, en: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""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) -> "void":
        r"""clear_max_hold(freq_sink_c self)"""
        return _qtgui_swig.freq_sink_c_clear_max_hold(self)

    def clear_min_hold(self) -> "void":
        r"""clear_min_hold(freq_sink_c self)"""
        return _qtgui_swig.freq_sink_c_clear_min_hold(self)

    def disable_legend(self) -> "void":
        r"""disable_legend(freq_sink_c self)"""
        return _qtgui_swig.freq_sink_c_disable_legend(self)

    def reset(self) -> "void":
        r"""reset(freq_sink_c self)"""
        return _qtgui_swig.freq_sink_c_reset(self)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(freq_sink_c self, bool en=True)"""
        return _qtgui_swig.freq_sink_c_enable_axis_labels(self, en)
    d_qApplication = property(_qtgui_swig.freq_sink_c_d_qApplication_get, _qtgui_swig.freq_sink_c_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_freq_sink_c

# Register freq_sink_c in _qtgui_swig:
_qtgui_swig.freq_sink_c_swigregister(freq_sink_c)

def freq_sink_c_make(fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::freq_sink_c::sptr":
    r"""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):
    r"""Proxy of C++ gr::qtgui::freq_sink_f class."""

    thisown = 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

    @staticmethod
    def make(fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::freq_sink_f::sptr":
        r"""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)

    def exec_(self) -> "void":
        r"""exec_(freq_sink_f self)"""
        return _qtgui_swig.freq_sink_f_exec_(self)

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

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

    def set_fft_size(self, fftsize: "int const") -> "void":
        r"""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) -> "int":
        r"""fft_size(freq_sink_f self) -> int"""
        return _qtgui_swig.freq_sink_f_fft_size(self)

    def set_fft_average(self, fftavg: "float const") -> "void":
        r"""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) -> "float":
        r"""fft_average(freq_sink_f self) -> float"""
        return _qtgui_swig.freq_sink_f_fft_average(self)

    def set_fft_window(self, win: "gr::filter::firdes::win_type const") -> "void":
        r"""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) -> "gr::filter::firdes::win_type":
        r"""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: "double const", bandwidth: "double const") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""set_title(freq_sink_f self, std::string const & title)"""
        return _qtgui_swig.freq_sink_f_set_title(self, title)

    def set_y_label(self, label: "std::string const &", unit: "std::string const &") -> "void":
        r"""set_y_label(freq_sink_f self, std::string const & label, std::string const & unit)"""
        return _qtgui_swig.freq_sink_f_set_y_label(self, label, unit)

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

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

    def set_line_width(self, which: "unsigned int", width: "int") -> "void":
        r"""set_line_width(freq_sink_f self, unsigned int which, int width)"""
        return _qtgui_swig.freq_sink_f_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(freq_sink_f self, unsigned int which, int style)"""
        return _qtgui_swig.freq_sink_f_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(freq_sink_f self, unsigned int which, int marker)"""
        return _qtgui_swig.freq_sink_f_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(freq_sink_f self, unsigned int which, double alpha)"""
        return _qtgui_swig.freq_sink_f_set_line_alpha(self, which, alpha)

    def set_plot_pos_half(self, half: "bool") -> "void":
        r"""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) -> "void":
        r"""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) -> "std::string":
        r"""title(freq_sink_f self) -> std::string"""
        return _qtgui_swig.freq_sink_f_title(self)

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""enable_menu(freq_sink_f self, bool en=True)"""
        return _qtgui_swig.freq_sink_f_enable_menu(self, en)

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

    def enable_autoscale(self, en: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""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) -> "void":
        r"""clear_max_hold(freq_sink_f self)"""
        return _qtgui_swig.freq_sink_f_clear_max_hold(self)

    def clear_min_hold(self) -> "void":
        r"""clear_min_hold(freq_sink_f self)"""
        return _qtgui_swig.freq_sink_f_clear_min_hold(self)

    def disable_legend(self) -> "void":
        r"""disable_legend(freq_sink_f self)"""
        return _qtgui_swig.freq_sink_f_disable_legend(self)

    def reset(self) -> "void":
        r"""reset(freq_sink_f self)"""
        return _qtgui_swig.freq_sink_f_reset(self)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(freq_sink_f self, bool en=True)"""
        return _qtgui_swig.freq_sink_f_enable_axis_labels(self, en)
    d_qApplication = property(_qtgui_swig.freq_sink_f_d_qApplication_get, _qtgui_swig.freq_sink_f_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_freq_sink_f

# Register freq_sink_f in _qtgui_swig:
_qtgui_swig.freq_sink_f_swigregister(freq_sink_f)

def freq_sink_f_make(fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::freq_sink_f::sptr":
    r"""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):
    r"""Proxy of C++ gr::qtgui::const_sink_c class."""

    thisown = 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

    @staticmethod
    def make(size: "int", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::const_sink_c::sptr":
        r"""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)

    def exec_(self) -> "void":
        r"""exec_(const_sink_c self)"""
        return _qtgui_swig.const_sink_c_exec_(self)

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

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

    def set_y_axis(self, min: "double", max: "double") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", label: "std::string const &") -> "void":
        r"""set_line_label(const_sink_c self, unsigned int which, std::string const & label)"""
        return _qtgui_swig.const_sink_c_set_line_label(self, which, label)

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

    def set_line_width(self, which: "unsigned int", width: "int") -> "void":
        r"""set_line_width(const_sink_c self, unsigned int which, int width)"""
        return _qtgui_swig.const_sink_c_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(const_sink_c self, unsigned int which, int style)"""
        return _qtgui_swig.const_sink_c_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(const_sink_c self, unsigned int which, int marker)"""
        return _qtgui_swig.const_sink_c_set_line_marker(self, which, marker)

    def set_nsamps(self, newsize: "int const") -> "void":
        r"""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: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(const_sink_c self, unsigned int which, double alpha)"""
        return _qtgui_swig.const_sink_c_set_line_alpha(self, which, alpha)

    def set_trigger_mode(self, *args, **kwargs) -> "void":
        r"""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) -> "std::string":
        r"""title(const_sink_c self) -> std::string"""
        return _qtgui_swig.const_sink_c_title(self)

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""enable_menu(const_sink_c self, bool en=True)"""
        return _qtgui_swig.const_sink_c_enable_menu(self, en)

    def enable_autoscale(self, en: "bool") -> "void":
        r"""enable_autoscale(const_sink_c self, bool en)"""
        return _qtgui_swig.const_sink_c_enable_autoscale(self, en)

    def enable_grid(self, en: "bool") -> "void":
        r"""enable_grid(const_sink_c self, bool en)"""
        return _qtgui_swig.const_sink_c_enable_grid(self, en)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(const_sink_c self, bool en=True)"""
        return _qtgui_swig.const_sink_c_enable_axis_labels(self, en)

    def disable_legend(self) -> "void":
        r"""disable_legend(const_sink_c self)"""
        return _qtgui_swig.const_sink_c_disable_legend(self)

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

    def reset(self) -> "void":
        r"""reset(const_sink_c self)"""
        return _qtgui_swig.const_sink_c_reset(self)
    d_qApplication = property(_qtgui_swig.const_sink_c_d_qApplication_get, _qtgui_swig.const_sink_c_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_const_sink_c

# Register const_sink_c in _qtgui_swig:
_qtgui_swig.const_sink_c_swigregister(const_sink_c)

def const_sink_c_make(size: "int", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::const_sink_c::sptr":
    r"""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):
    r"""Proxy of C++ gr::qtgui::waterfall_sink_c class."""

    thisown = 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

    @staticmethod
    def make(size: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::waterfall_sink_c::sptr":
        r"""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)

    def exec_(self) -> "void":
        r"""exec_(waterfall_sink_c self)"""
        return _qtgui_swig.waterfall_sink_c_exec_(self)

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

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

    def clear_data(self) -> "void":
        r"""clear_data(waterfall_sink_c self)"""
        return _qtgui_swig.waterfall_sink_c_clear_data(self)

    def set_fft_size(self, fftsize: "int const") -> "void":
        r"""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) -> "int":
        r"""fft_size(waterfall_sink_c self) -> int"""
        return _qtgui_swig.waterfall_sink_c_fft_size(self)

    def set_time_per_fft(self, t: "double const") -> "void":
        r"""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: "float const") -> "void":
        r"""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) -> "float":
        r"""fft_average(waterfall_sink_c self) -> float"""
        return _qtgui_swig.waterfall_sink_c_fft_average(self)

    def set_fft_window(self, win: "gr::filter::firdes::win_type const") -> "void":
        r"""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) -> "gr::filter::firdes::win_type":
        r"""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: "double const", bandwidth: "double const") -> "void":
        r"""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: "double const", max: "double const") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", line: "std::string const &") -> "void":
        r"""set_line_label(waterfall_sink_c self, unsigned int which, std::string const & line)"""
        return _qtgui_swig.waterfall_sink_c_set_line_label(self, which, line)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(waterfall_sink_c self, unsigned int which, double alpha)"""
        return _qtgui_swig.waterfall_sink_c_set_line_alpha(self, which, alpha)

    def set_color_map(self, which: "unsigned int", color: "int const") -> "void":
        r"""set_color_map(waterfall_sink_c self, unsigned int which, int const color)"""
        return _qtgui_swig.waterfall_sink_c_set_color_map(self, which, color)

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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) -> "void":
        r"""auto_scale(waterfall_sink_c self)"""
        return _qtgui_swig.waterfall_sink_c_auto_scale(self)

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

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

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

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

    def disable_legend(self) -> "void":
        r"""disable_legend(waterfall_sink_c self)"""
        return _qtgui_swig.waterfall_sink_c_disable_legend(self)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(waterfall_sink_c self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_c_enable_axis_labels(self, en)
    d_qApplication = property(_qtgui_swig.waterfall_sink_c_d_qApplication_get, _qtgui_swig.waterfall_sink_c_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_waterfall_sink_c

# Register waterfall_sink_c in _qtgui_swig:
_qtgui_swig.waterfall_sink_c_swigregister(waterfall_sink_c)

def waterfall_sink_c_make(size: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::waterfall_sink_c::sptr":
    r"""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):
    r"""Proxy of C++ gr::qtgui::waterfall_sink_f class."""

    thisown = 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

    @staticmethod
    def make(size: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::waterfall_sink_f::sptr":
        r"""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)

    def exec_(self) -> "void":
        r"""exec_(waterfall_sink_f self)"""
        return _qtgui_swig.waterfall_sink_f_exec_(self)

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

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

    def clear_data(self) -> "void":
        r"""clear_data(waterfall_sink_f self)"""
        return _qtgui_swig.waterfall_sink_f_clear_data(self)

    def set_fft_size(self, fftsize: "int const") -> "void":
        r"""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) -> "int":
        r"""fft_size(waterfall_sink_f self) -> int"""
        return _qtgui_swig.waterfall_sink_f_fft_size(self)

    def set_time_per_fft(self, t: "double const") -> "void":
        r"""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: "float const") -> "void":
        r"""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) -> "float":
        r"""fft_average(waterfall_sink_f self) -> float"""
        return _qtgui_swig.waterfall_sink_f_fft_average(self)

    def set_fft_window(self, win: "gr::filter::firdes::win_type const") -> "void":
        r"""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) -> "gr::filter::firdes::win_type":
        r"""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: "double const", bandwidth: "double const") -> "void":
        r"""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: "double const", max: "double const") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", line: "std::string const &") -> "void":
        r"""set_line_label(waterfall_sink_f self, unsigned int which, std::string const & line)"""
        return _qtgui_swig.waterfall_sink_f_set_line_label(self, which, line)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(waterfall_sink_f self, unsigned int which, double alpha)"""
        return _qtgui_swig.waterfall_sink_f_set_line_alpha(self, which, alpha)

    def set_color_map(self, which: "unsigned int", color: "int const") -> "void":
        r"""set_color_map(waterfall_sink_f self, unsigned int which, int const color)"""
        return _qtgui_swig.waterfall_sink_f_set_color_map(self, which, color)

    def set_plot_pos_half(self, half: "bool") -> "void":
        r"""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) -> "std::string":
        r"""title(waterfall_sink_f self) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_title(self)

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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) -> "void":
        r"""auto_scale(waterfall_sink_f self)"""
        return _qtgui_swig.waterfall_sink_f_auto_scale(self)

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

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

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

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

    def disable_legend(self) -> "void":
        r"""disable_legend(waterfall_sink_f self)"""
        return _qtgui_swig.waterfall_sink_f_disable_legend(self)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(waterfall_sink_f self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_f_enable_axis_labels(self, en)
    d_qApplication = property(_qtgui_swig.waterfall_sink_f_d_qApplication_get, _qtgui_swig.waterfall_sink_f_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_waterfall_sink_f

# Register waterfall_sink_f in _qtgui_swig:
_qtgui_swig.waterfall_sink_f_swigregister(waterfall_sink_f)

def waterfall_sink_f_make(size: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::waterfall_sink_f::sptr":
    r"""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):
    r"""Proxy of C++ gr::qtgui::histogram_sink_f class."""

    thisown = 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

    @staticmethod
    def make(size: "int", bins: "int", xmin: "double", xmax: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::histogram_sink_f::sptr":
        r"""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)

    def exec_(self) -> "void":
        r"""exec_(histogram_sink_f self)"""
        return _qtgui_swig.histogram_sink_f_exec_(self)

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

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

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

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""enable_menu(histogram_sink_f self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_enable_menu(self, en)

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

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

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

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

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

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(histogram_sink_f self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_enable_axis_labels(self, en)

    def autoscalex(self) -> "void":
        r"""autoscalex(histogram_sink_f self)"""
        return _qtgui_swig.histogram_sink_f_autoscalex(self)

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

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

    def reset(self) -> "void":
        r"""reset(histogram_sink_f self)"""
        return _qtgui_swig.histogram_sink_f_reset(self)
    d_qApplication = property(_qtgui_swig.histogram_sink_f_d_qApplication_get, _qtgui_swig.histogram_sink_f_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def set_y_axis(self, min: "double", max: "double") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", line: "std::string const &") -> "void":
        r"""set_line_label(histogram_sink_f self, unsigned int which, std::string const & line)"""
        return _qtgui_swig.histogram_sink_f_set_line_label(self, which, line)

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

    def set_line_width(self, which: "unsigned int", width: "int") -> "void":
        r"""set_line_width(histogram_sink_f self, unsigned int which, int width)"""
        return _qtgui_swig.histogram_sink_f_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(histogram_sink_f self, unsigned int which, int style)"""
        return _qtgui_swig.histogram_sink_f_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(histogram_sink_f self, unsigned int which, int marker)"""
        return _qtgui_swig.histogram_sink_f_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(histogram_sink_f self, unsigned int which, double alpha)"""
        return _qtgui_swig.histogram_sink_f_set_line_alpha(self, which, alpha)

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

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

    def disable_legend(self) -> "void":
        r"""disable_legend(histogram_sink_f self)"""
        return _qtgui_swig.histogram_sink_f_disable_legend(self)
    __swig_destroy__ = _qtgui_swig.delete_histogram_sink_f

# Register histogram_sink_f in _qtgui_swig:
_qtgui_swig.histogram_sink_f_swigregister(histogram_sink_f)

def histogram_sink_f_make(size: "int", bins: "int", xmin: "double", xmax: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::histogram_sink_f::sptr":
    r"""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):
    r"""Proxy of C++ gr::qtgui::number_sink class."""

    thisown = 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

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

    def exec_(self) -> "void":
        r"""exec_(number_sink self)"""
        return _qtgui_swig.number_sink_exec_(self)

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

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

    def set_update_time(self, t: "double") -> "void":
        r"""set_update_time(number_sink self, double t)"""
        return _qtgui_swig.number_sink_set_update_time(self, t)

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

    def set_graph_type(self, type: "gr::qtgui::graph_t const") -> "void":
        r"""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) -> "void":
        r"""
        set_color(number_sink self, unsigned int which, std::string const & min, std::string const & max)
        set_color(number_sink self, unsigned int which, int min, int max)
        """
        return _qtgui_swig.number_sink_set_color(self, *args)

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

    def set_min(self, which: "unsigned int", min: "float") -> "void":
        r"""set_min(number_sink self, unsigned int which, float min)"""
        return _qtgui_swig.number_sink_set_min(self, which, min)

    def set_max(self, which: "unsigned int", max: "float") -> "void":
        r"""set_max(number_sink self, unsigned int which, float max)"""
        return _qtgui_swig.number_sink_set_max(self, which, max)

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

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

    def set_factor(self, which: "unsigned int", factor: "float") -> "void":
        r"""set_factor(number_sink self, unsigned int which, float factor)"""
        return _qtgui_swig.number_sink_set_factor(self, which, factor)

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

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

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

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

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

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

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

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

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

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

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

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

    def reset(self) -> "void":
        r"""reset(number_sink self)"""
        return _qtgui_swig.number_sink_reset(self)
    d_qApplication = property(_qtgui_swig.number_sink_d_qApplication_get, _qtgui_swig.number_sink_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_number_sink

# Register number_sink in _qtgui_swig:
_qtgui_swig.number_sink_swigregister(number_sink)

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

class ber_sink_b(object):
    r"""Proxy of C++ gr::qtgui::ber_sink_b class."""

    thisown = 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

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

    def exec_(self) -> "void":
        r"""exec_(ber_sink_b self)"""
        return _qtgui_swig.ber_sink_b_exec_(self)

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

    def set_y_axis(self, min: "double", max: "double") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", label: "std::string const &") -> "void":
        r"""set_line_label(ber_sink_b self, unsigned int which, std::string const & label)"""
        return _qtgui_swig.ber_sink_b_set_line_label(self, which, label)

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

    def set_line_width(self, which: "unsigned int", width: "int") -> "void":
        r"""set_line_width(ber_sink_b self, unsigned int which, int width)"""
        return _qtgui_swig.ber_sink_b_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(ber_sink_b self, unsigned int which, int style)"""
        return _qtgui_swig.ber_sink_b_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(ber_sink_b self, unsigned int which, int marker)"""
        return _qtgui_swig.ber_sink_b_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(ber_sink_b self, unsigned int which, double alpha)"""
        return _qtgui_swig.ber_sink_b_set_line_alpha(self, which, alpha)

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

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""enable_menu(ber_sink_b self, bool en=True)"""
        return _qtgui_swig.ber_sink_b_enable_menu(self, en)

    def enable_autoscale(self, en: "bool") -> "void":
        r"""enable_autoscale(ber_sink_b self, bool en)"""
        return _qtgui_swig.ber_sink_b_enable_autoscale(self, en)

    def nsamps(self) -> "int":
        r"""nsamps(ber_sink_b self) -> int"""
        return _qtgui_swig.ber_sink_b_nsamps(self)
    d_qApplication = property(_qtgui_swig.ber_sink_b_d_qApplication_get, _qtgui_swig.ber_sink_b_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_ber_sink_b

# Register ber_sink_b in _qtgui_swig:
_qtgui_swig.ber_sink_b_swigregister(ber_sink_b)

def ber_sink_b_make(*args, **kwargs) -> "gr::qtgui::ber_sink_b::sptr":
    r"""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=std::vector< std::string >(), QWidget * parent=None) -> ber_sink_b_sptr"""
    return _qtgui_swig.ber_sink_b_make(*args, **kwargs)

class vector_sink_f(object):
    r"""Proxy of C++ gr::qtgui::vector_sink_f class."""

    thisown = 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

    @staticmethod
    def make(vlen: "unsigned int", x_start: "double", x_step: "double", x_axis_label: "std::string const &", y_axis_label: "std::string const &", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::vector_sink_f::sptr":
        r"""make(unsigned 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)

    def exec_(self) -> "void":
        r"""exec_(vector_sink_f self)"""
        return _qtgui_swig.vector_sink_f_exec_(self)

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

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

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

    def set_vec_average(self, avg: "float const") -> "void":
        r"""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) -> "float":
        r"""vec_average(vector_sink_f self) -> float"""
        return _qtgui_swig.vector_sink_f_vec_average(self)

    def set_x_axis(self, start: "double const", step: "double const") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", label: "std::string const &") -> "void":
        r"""set_line_label(vector_sink_f self, unsigned int which, std::string const & label)"""
        return _qtgui_swig.vector_sink_f_set_line_label(self, which, label)

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

    def set_line_width(self, which: "unsigned int", width: "int") -> "void":
        r"""set_line_width(vector_sink_f self, unsigned int which, int width)"""
        return _qtgui_swig.vector_sink_f_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(vector_sink_f self, unsigned int which, int style)"""
        return _qtgui_swig.vector_sink_f_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(vector_sink_f self, unsigned int which, int marker)"""
        return _qtgui_swig.vector_sink_f_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(vector_sink_f self, unsigned int which, double alpha)"""
        return _qtgui_swig.vector_sink_f_set_line_alpha(self, which, alpha)

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

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""enable_menu(vector_sink_f self, bool en=True)"""
        return _qtgui_swig.vector_sink_f_enable_menu(self, en)

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

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

    def clear_max_hold(self) -> "void":
        r"""clear_max_hold(vector_sink_f self)"""
        return _qtgui_swig.vector_sink_f_clear_max_hold(self)

    def clear_min_hold(self) -> "void":
        r"""clear_min_hold(vector_sink_f self)"""
        return _qtgui_swig.vector_sink_f_clear_min_hold(self)

    def reset(self) -> "void":
        r"""reset(vector_sink_f self)"""
        return _qtgui_swig.vector_sink_f_reset(self)
    d_qApplication = property(_qtgui_swig.vector_sink_f_d_qApplication_get, _qtgui_swig.vector_sink_f_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_vector_sink_f

# Register vector_sink_f in _qtgui_swig:
_qtgui_swig.vector_sink_f_swigregister(vector_sink_f)

def vector_sink_f_make(vlen: "unsigned int", x_start: "double", x_step: "double", x_axis_label: "std::string const &", y_axis_label: "std::string const &", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::vector_sink_f::sptr":
    r"""vector_sink_f_make(unsigned 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 edit_box_msg(object):
    r"""Proxy of C++ gr::qtgui::edit_box_msg class."""

    thisown = 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

    @staticmethod
    def make(*args, **kwargs) -> "gr::qtgui::edit_box_msg::sptr":
        r"""make(gr::qtgui::data_type_t type, std::string const & value="", std::string const & label="", bool is_pair=True, bool is_static=True, std::string const & key="", QWidget * parent=None) -> edit_box_msg_sptr"""
        return _qtgui_swig.edit_box_msg_make(*args, **kwargs)

    def exec_(self) -> "void":
        r"""exec_(edit_box_msg self)"""
        return _qtgui_swig.edit_box_msg_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(edit_box_msg self) -> QWidget *"""
        return _qtgui_swig.edit_box_msg_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(edit_box_msg self) -> PyObject *"""
        return _qtgui_swig.edit_box_msg_pyqwidget(self)
    d_qApplication = property(_qtgui_swig.edit_box_msg_d_qApplication_get, _qtgui_swig.edit_box_msg_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")
    __swig_destroy__ = _qtgui_swig.delete_edit_box_msg

# Register edit_box_msg in _qtgui_swig:
_qtgui_swig.edit_box_msg_swigregister(edit_box_msg)

def edit_box_msg_make(*args, **kwargs) -> "gr::qtgui::edit_box_msg::sptr":
    r"""edit_box_msg_make(gr::qtgui::data_type_t type, std::string const & value="", std::string const & label="", bool is_pair=True, bool is_static=True, std::string const & key="", QWidget * parent=None) -> edit_box_msg_sptr"""
    return _qtgui_swig.edit_box_msg_make(*args, **kwargs)

class sink_c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::sink_c > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(sink_c_sptr self) -> sink_c_sptr
        __init__(sink_c_sptr self, sink_c p) -> sink_c_sptr
        """
        _qtgui_swig.sink_c_sptr_swiginit(self, _qtgui_swig.new_sink_c_sptr(*args))

    def __deref__(self) -> "gr::qtgui::sink_c *":
        r"""__deref__(sink_c_sptr self) -> sink_c"""
        return _qtgui_swig.sink_c_sptr___deref__(self)
    __swig_destroy__ = _qtgui_swig.delete_sink_c_sptr

    def make(self, fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", plotfreq: "bool", plotwaterfall: "bool", plottime: "bool", plotconst: "bool", parent: "QWidget *"=None) -> "gr::qtgui::sink_c::sptr":
        r"""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) -> "void":
        r"""exec_(sink_c_sptr self)"""
        return _qtgui_swig.sink_c_sptr_exec_(self)

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

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

    def set_fft_size(self, fftsize: "int const") -> "void":
        r"""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) -> "int":
        r"""fft_size(sink_c_sptr self) -> int"""
        return _qtgui_swig.sink_c_sptr_fft_size(self)

    def set_frequency_range(self, centerfreq: "double const", bandwidth: "double const") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "bool") -> "void":
        r"""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: "double") -> "void":
        r"""set_update_time(sink_c_sptr self, double t)"""
        return _qtgui_swig.sink_c_sptr_set_update_time(self, t)
    d_qApplication = property(_qtgui_swig.sink_c_sptr_d_qApplication_get, _qtgui_swig.sink_c_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

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

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(sink_c_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.sink_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sink_c_sptr self, int multiple)"""
        return _qtgui_swig.sink_c_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sink_c_sptr self) -> uint64_t"""
        return _qtgui_swig.sink_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sink_c_sptr self) -> uint64_t"""
        return _qtgui_swig.sink_c_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(sink_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.sink_c_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sink_c_sptr self, std::string level)"""
        return _qtgui_swig.sink_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sink_c_sptr self) -> std::string"""
        return _qtgui_swig.sink_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(sink_c_sptr self) -> int"""
        return _qtgui_swig.sink_c_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_noutput_items_var(self)

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

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

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(sink_c_sptr self) -> float"""
        return _qtgui_swig.sink_c_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(sink_c_sptr self)"""
        return _qtgui_swig.sink_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(sink_c_sptr self) -> int"""
        return _qtgui_swig.sink_c_sptr_active_thread_priority(self)

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

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

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

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

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.sink_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.sink_c_sptr_output_signature(self)

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

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(sink_c_sptr self) -> std::string"""
        return _qtgui_swig.sink_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sink_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.sink_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sink_c_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.sink_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sink_c_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.sink_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sink_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.sink_c_sptr_message_subscribers(self, which_port)

# Register sink_c_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::sink_f > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(sink_f_sptr self) -> sink_f_sptr
        __init__(sink_f_sptr self, sink_f p) -> sink_f_sptr
        """
        _qtgui_swig.sink_f_sptr_swiginit(self, _qtgui_swig.new_sink_f_sptr(*args))

    def __deref__(self) -> "gr::qtgui::sink_f *":
        r"""__deref__(sink_f_sptr self) -> sink_f"""
        return _qtgui_swig.sink_f_sptr___deref__(self)
    __swig_destroy__ = _qtgui_swig.delete_sink_f_sptr

    def make(self, fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", plotfreq: "bool", plotwaterfall: "bool", plottime: "bool", plotconst: "bool", parent: "QWidget *"=None) -> "gr::qtgui::sink_f::sptr":
        r"""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) -> "void":
        r"""exec_(sink_f_sptr self)"""
        return _qtgui_swig.sink_f_sptr_exec_(self)

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

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

    def set_fft_size(self, fftsize: "int const") -> "void":
        r"""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) -> "int":
        r"""fft_size(sink_f_sptr self) -> int"""
        return _qtgui_swig.sink_f_sptr_fft_size(self)

    def set_frequency_range(self, centerfreq: "double const", bandwidth: "double const") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "bool") -> "void":
        r"""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: "double") -> "void":
        r"""set_update_time(sink_f_sptr self, double t)"""
        return _qtgui_swig.sink_f_sptr_set_update_time(self, t)
    d_qApplication = property(_qtgui_swig.sink_f_sptr_d_qApplication_get, _qtgui_swig.sink_f_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

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

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.sink_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(sink_f_sptr self, int multiple)"""
        return _qtgui_swig.sink_f_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.sink_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.sink_f_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.sink_f_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(sink_f_sptr self, std::string level)"""
        return _qtgui_swig.sink_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(sink_f_sptr self) -> std::string"""
        return _qtgui_swig.sink_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(sink_f_sptr self) -> int"""
        return _qtgui_swig.sink_f_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_noutput_items_var(self)

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

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

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(sink_f_sptr self) -> float"""
        return _qtgui_swig.sink_f_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(sink_f_sptr self)"""
        return _qtgui_swig.sink_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(sink_f_sptr self) -> int"""
        return _qtgui_swig.sink_f_sptr_active_thread_priority(self)

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

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

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

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

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.sink_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.sink_f_sptr_output_signature(self)

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

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(sink_f_sptr self) -> std::string"""
        return _qtgui_swig.sink_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(sink_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.sink_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.sink_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.sink_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(sink_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.sink_f_sptr_message_subscribers(self, which_port)

# Register sink_f_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::time_sink_c > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(time_sink_c_sptr self) -> time_sink_c_sptr
        __init__(time_sink_c_sptr self, time_sink_c p) -> time_sink_c_sptr
        """
        _qtgui_swig.time_sink_c_sptr_swiginit(self, _qtgui_swig.new_time_sink_c_sptr(*args))

    def __deref__(self) -> "gr::qtgui::time_sink_c *":
        r"""__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

    def make(self, size: "int", samp_rate: "double", name: "std::string const &", nconnections: "unsigned int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_sink_c::sptr":
        r"""make(time_sink_c_sptr self, int size, double samp_rate, std::string const & name, unsigned 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) -> "void":
        r"""exec_(time_sink_c_sptr self)"""
        return _qtgui_swig.time_sink_c_sptr_exec_(self)

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

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

    def set_y_axis(self, min: "double", max: "double") -> "void":
        r"""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) -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", label: "std::string const &") -> "void":
        r"""set_line_label(time_sink_c_sptr self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(time_sink_c_sptr self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(time_sink_c_sptr self, unsigned int which, int width)"""
        return _qtgui_swig.time_sink_c_sptr_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(time_sink_c_sptr self, unsigned int which, int style)"""
        return _qtgui_swig.time_sink_c_sptr_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(time_sink_c_sptr self, unsigned int which, int marker)"""
        return _qtgui_swig.time_sink_c_sptr_set_line_marker(self, which, marker)

    def set_nsamps(self, newsize: "int const") -> "void":
        r"""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: "double const") -> "void":
        r"""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: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(time_sink_c_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.time_sink_c_sptr_set_line_alpha(self, which, alpha)

    def set_trigger_mode(self, *args, **kwargs) -> "void":
        r"""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) -> "std::string":
        r"""title(time_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_c_sptr_title(self)

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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, *args) -> "void":
        r"""
        enable_tags(time_sink_c_sptr self, unsigned int which, bool en)
        enable_tags(time_sink_c_sptr self, bool en)
        """
        return _qtgui_swig.time_sink_c_sptr_enable_tags(self, *args)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(time_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_c_sptr_enable_axis_labels(self, en)

    def disable_legend(self) -> "void":
        r"""disable_legend(time_sink_c_sptr self)"""
        return _qtgui_swig.time_sink_c_sptr_disable_legend(self)

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

    def reset(self) -> "void":
        r"""reset(time_sink_c_sptr self)"""
        return _qtgui_swig.time_sink_c_sptr_reset(self)
    d_qApplication = property(_qtgui_swig.time_sink_c_sptr_d_qApplication_get, _qtgui_swig.time_sink_c_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

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

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(time_sink_c_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.time_sink_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(time_sink_c_sptr self, int multiple)"""
        return _qtgui_swig.time_sink_c_sptr_set_output_multiple(self, multiple)

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

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

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(time_sink_c_sptr self) -> uint64_t"""
        return _qtgui_swig.time_sink_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(time_sink_c_sptr self) -> uint64_t"""
        return _qtgui_swig.time_sink_c_sptr_relative_rate_d(self)

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

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

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(time_sink_c_sptr self, std::string level)"""
        return _qtgui_swig.time_sink_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(time_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(time_sink_c_sptr self) -> float"""
        return _qtgui_swig.time_sink_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(time_sink_c_sptr self)"""
        return _qtgui_swig.time_sink_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(time_sink_c_sptr self) -> int"""
        return _qtgui_swig.time_sink_c_sptr_active_thread_priority(self)

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

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(time_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_c_sptr_name(self)

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

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(time_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_sink_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(time_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_sink_c_sptr_output_signature(self)

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

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(time_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(time_sink_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.time_sink_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(time_sink_c_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.time_sink_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(time_sink_c_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.time_sink_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(time_sink_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.time_sink_c_sptr_message_subscribers(self, which_port)

# Register time_sink_c_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::time_sink_f > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(time_sink_f_sptr self) -> time_sink_f_sptr
        __init__(time_sink_f_sptr self, time_sink_f p) -> time_sink_f_sptr
        """
        _qtgui_swig.time_sink_f_sptr_swiginit(self, _qtgui_swig.new_time_sink_f_sptr(*args))

    def __deref__(self) -> "gr::qtgui::time_sink_f *":
        r"""__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

    def make(self, size: "int", samp_rate: "double", name: "std::string const &", nconnections: "unsigned int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_sink_f::sptr":
        r"""make(time_sink_f_sptr self, int size, double samp_rate, std::string const & name, unsigned 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) -> "void":
        r"""exec_(time_sink_f_sptr self)"""
        return _qtgui_swig.time_sink_f_sptr_exec_(self)

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

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

    def set_y_axis(self, min: "double", max: "double") -> "void":
        r"""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) -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", line: "std::string const &") -> "void":
        r"""set_line_label(time_sink_f_sptr self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(time_sink_f_sptr self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(time_sink_f_sptr self, unsigned int which, int width)"""
        return _qtgui_swig.time_sink_f_sptr_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(time_sink_f_sptr self, unsigned int which, int style)"""
        return _qtgui_swig.time_sink_f_sptr_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(time_sink_f_sptr self, unsigned int which, int marker)"""
        return _qtgui_swig.time_sink_f_sptr_set_line_marker(self, which, marker)

    def set_nsamps(self, newsize: "int const") -> "void":
        r"""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: "double const") -> "void":
        r"""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: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(time_sink_f_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.time_sink_f_sptr_set_line_alpha(self, which, alpha)

    def set_trigger_mode(self, *args, **kwargs) -> "void":
        r"""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) -> "std::string":
        r"""title(time_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_f_sptr_title(self)

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

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

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

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

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

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

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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, *args) -> "void":
        r"""
        enable_tags(time_sink_f_sptr self, unsigned int which, bool en)
        enable_tags(time_sink_f_sptr self, bool en)
        """
        return _qtgui_swig.time_sink_f_sptr_enable_tags(self, *args)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(time_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.time_sink_f_sptr_enable_axis_labels(self, en)

    def disable_legend(self) -> "void":
        r"""disable_legend(time_sink_f_sptr self)"""
        return _qtgui_swig.time_sink_f_sptr_disable_legend(self)

    def nsamps(self) -> "int":
        r"""nsamps(time_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_sink_f_sptr_nsamps(self)

    def reset(self) -> "void":
        r"""reset(time_sink_f_sptr self)"""
        return _qtgui_swig.time_sink_f_sptr_reset(self)
    d_qApplication = property(_qtgui_swig.time_sink_f_sptr_d_qApplication_get, _qtgui_swig.time_sink_f_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""history(time_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.time_sink_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(time_sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.time_sink_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(time_sink_f_sptr self, int multiple)"""
        return _qtgui_swig.time_sink_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(time_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_sink_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(time_sink_f_sptr self) -> double"""
        return _qtgui_swig.time_sink_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(time_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.time_sink_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(time_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.time_sink_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(time_sink_f_sptr self) -> bool"""
        return _qtgui_swig.time_sink_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(time_sink_f_sptr self) -> bool"""
        return _qtgui_swig.time_sink_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(time_sink_f_sptr self, std::string level)"""
        return _qtgui_swig.time_sink_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(time_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(time_sink_f_sptr self) -> float"""
        return _qtgui_swig.time_sink_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(time_sink_f_sptr self)"""
        return _qtgui_swig.time_sink_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(time_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_sink_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(time_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_sink_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(time_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(time_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(time_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_sink_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(time_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.time_sink_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(time_sink_f_sptr self) -> long"""
        return _qtgui_swig.time_sink_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(time_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_sink_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(time_sink_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.time_sink_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(time_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.time_sink_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(time_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.time_sink_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(time_sink_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.time_sink_f_sptr_message_subscribers(self, which_port)

# Register time_sink_f_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::time_raster_sink_b > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(time_raster_sink_b_sptr self) -> time_raster_sink_b_sptr
        __init__(time_raster_sink_b_sptr self, time_raster_sink_b p) -> time_raster_sink_b_sptr
        """
        _qtgui_swig.time_raster_sink_b_sptr_swiginit(self, _qtgui_swig.new_time_raster_sink_b_sptr(*args))

    def __deref__(self) -> "gr::qtgui::time_raster_sink_b *":
        r"""__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

    def make(self, samp_rate: "double", rows: "double", cols: "double", mult: "pmt_vector_float", offset: "pmt_vector_float", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_raster_sink_b::sptr":
        r"""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) -> "void":
        r"""exec_(time_raster_sink_b_sptr self)"""
        return _qtgui_swig.time_raster_sink_b_sptr_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(time_raster_sink_b_sptr self) -> QWidget *"""
        return _qtgui_swig.time_raster_sink_b_sptr_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(time_raster_sink_b_sptr self) -> PyObject *"""
        return _qtgui_swig.time_raster_sink_b_sptr_pyqwidget(self)

    def set_update_time(self, t: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", lable: "std::string const &") -> "void":
        r"""set_line_label(time_raster_sink_b_sptr self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(time_raster_sink_b_sptr self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(time_raster_sink_b_sptr self, unsigned int which, int width)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "Qt::PenStyle") -> "void":
        r"""set_line_style(time_raster_sink_b_sptr self, unsigned 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: "unsigned int", marker: "QwtSymbol::Style") -> "void":
        r"""set_line_marker(time_raster_sink_b_sptr self, unsigned 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: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(time_raster_sink_b_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_line_alpha(self, which, alpha)

    def set_color_map(self, which: "unsigned int", color: "int const") -> "void":
        r"""set_color_map(time_raster_sink_b_sptr self, unsigned int which, int const color)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_color_map(self, which, color)

    def title(self) -> "std::string":
        r"""title(time_raster_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_sptr_title(self)

    def line_label(self, which: "unsigned int") -> "std::string":
        r"""line_label(time_raster_sink_b_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_label(self, which)

    def line_color(self, which: "unsigned int") -> "std::string":
        r"""line_color(time_raster_sink_b_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_color(self, which)

    def line_width(self, which: "unsigned int") -> "int":
        r"""line_width(time_raster_sink_b_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_width(self, which)

    def line_style(self, which: "unsigned int") -> "int":
        r"""line_style(time_raster_sink_b_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_style(self, which)

    def line_marker(self, which: "unsigned int") -> "int":
        r"""line_marker(time_raster_sink_b_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_marker(self, which)

    def line_alpha(self, which: "unsigned int") -> "double":
        r"""line_alpha(time_raster_sink_b_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.time_raster_sink_b_sptr_line_alpha(self, which)

    def color_map(self, which: "unsigned int") -> "int":
        r"""color_map(time_raster_sink_b_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_color_map(self, which)

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "double const") -> "void":
        r"""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: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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) -> "double":
        r"""num_rows(time_raster_sink_b_sptr self) -> double"""
        return _qtgui_swig.time_raster_sink_b_sptr_num_rows(self)

    def num_cols(self) -> "double":
        r"""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: "pmt_vector_float") -> "void":
        r"""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: "pmt_vector_float") -> "void":
        r"""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: "float", max: "float") -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""enable_autoscale(time_raster_sink_b_sptr self, bool en)"""
        return _qtgui_swig.time_raster_sink_b_sptr_enable_autoscale(self, en)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(time_raster_sink_b_sptr self, bool en=True)"""
        return _qtgui_swig.time_raster_sink_b_sptr_enable_axis_labels(self, en)

    def reset(self) -> "void":
        r"""reset(time_raster_sink_b_sptr self)"""
        return _qtgui_swig.time_raster_sink_b_sptr_reset(self)
    d_qApplication = property(_qtgui_swig.time_raster_sink_b_sptr_d_qApplication_get, _qtgui_swig.time_raster_sink_b_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""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) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""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 set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(time_raster_sink_b_sptr self, int multiple)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(time_raster_sink_b_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_b_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(time_raster_sink_b_sptr self) -> double"""
        return _qtgui_swig.time_raster_sink_b_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(time_raster_sink_b_sptr self) -> uint64_t"""
        return _qtgui_swig.time_raster_sink_b_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(time_raster_sink_b_sptr self) -> uint64_t"""
        return _qtgui_swig.time_raster_sink_b_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(time_raster_sink_b_sptr self) -> bool"""
        return _qtgui_swig.time_raster_sink_b_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(time_raster_sink_b_sptr self) -> bool"""
        return _qtgui_swig.time_raster_sink_b_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(time_raster_sink_b_sptr self, std::string level)"""
        return _qtgui_swig.time_raster_sink_b_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(time_raster_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""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) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""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) -> "int":
        r"""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: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(time_raster_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_b_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "long":
        r"""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) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""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: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(time_raster_sink_b_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.time_raster_sink_b_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(time_raster_sink_b_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.time_raster_sink_b_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(time_raster_sink_b_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.time_raster_sink_b_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(time_raster_sink_b_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.time_raster_sink_b_sptr_message_subscribers(self, which_port)

# Register time_raster_sink_b_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::time_raster_sink_f > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(time_raster_sink_f_sptr self) -> time_raster_sink_f_sptr
        __init__(time_raster_sink_f_sptr self, time_raster_sink_f p) -> time_raster_sink_f_sptr
        """
        _qtgui_swig.time_raster_sink_f_sptr_swiginit(self, _qtgui_swig.new_time_raster_sink_f_sptr(*args))

    def __deref__(self) -> "gr::qtgui::time_raster_sink_f *":
        r"""__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

    def make(self, samp_rate: "double", rows: "double", cols: "double", mult: "pmt_vector_float", offset: "pmt_vector_float", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::time_raster_sink_f::sptr":
        r"""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) -> "void":
        r"""exec_(time_raster_sink_f_sptr self)"""
        return _qtgui_swig.time_raster_sink_f_sptr_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(time_raster_sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.time_raster_sink_f_sptr_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(time_raster_sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.time_raster_sink_f_sptr_pyqwidget(self)

    def set_update_time(self, t: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", lable: "std::string const &") -> "void":
        r"""set_line_label(time_raster_sink_f_sptr self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(time_raster_sink_f_sptr self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(time_raster_sink_f_sptr self, unsigned int which, int width)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "Qt::PenStyle") -> "void":
        r"""set_line_style(time_raster_sink_f_sptr self, unsigned 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: "unsigned int", marker: "QwtSymbol::Style") -> "void":
        r"""set_line_marker(time_raster_sink_f_sptr self, unsigned 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: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(time_raster_sink_f_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_line_alpha(self, which, alpha)

    def set_color_map(self, which: "unsigned int", color: "int const") -> "void":
        r"""set_color_map(time_raster_sink_f_sptr self, unsigned int which, int const color)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_color_map(self, which, color)

    def title(self) -> "std::string":
        r"""title(time_raster_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_sptr_title(self)

    def line_label(self, which: "unsigned int") -> "std::string":
        r"""line_label(time_raster_sink_f_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_label(self, which)

    def line_color(self, which: "unsigned int") -> "std::string":
        r"""line_color(time_raster_sink_f_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_color(self, which)

    def line_width(self, which: "unsigned int") -> "int":
        r"""line_width(time_raster_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_width(self, which)

    def line_style(self, which: "unsigned int") -> "int":
        r"""line_style(time_raster_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_style(self, which)

    def line_marker(self, which: "unsigned int") -> "int":
        r"""line_marker(time_raster_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_marker(self, which)

    def line_alpha(self, which: "unsigned int") -> "double":
        r"""line_alpha(time_raster_sink_f_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.time_raster_sink_f_sptr_line_alpha(self, which)

    def color_map(self, which: "unsigned int") -> "int":
        r"""color_map(time_raster_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_color_map(self, which)

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "double const") -> "void":
        r"""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: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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) -> "double":
        r"""num_rows(time_raster_sink_f_sptr self) -> double"""
        return _qtgui_swig.time_raster_sink_f_sptr_num_rows(self)

    def num_cols(self) -> "double":
        r"""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: "pmt_vector_float") -> "void":
        r"""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: "pmt_vector_float") -> "void":
        r"""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: "float", max: "float") -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""enable_autoscale(time_raster_sink_f_sptr self, bool en)"""
        return _qtgui_swig.time_raster_sink_f_sptr_enable_autoscale(self, en)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(time_raster_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.time_raster_sink_f_sptr_enable_axis_labels(self, en)

    def reset(self) -> "void":
        r"""reset(time_raster_sink_f_sptr self)"""
        return _qtgui_swig.time_raster_sink_f_sptr_reset(self)
    d_qApplication = property(_qtgui_swig.time_raster_sink_f_sptr_d_qApplication_get, _qtgui_swig.time_raster_sink_f_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""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) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""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 set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(time_raster_sink_f_sptr self, int multiple)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(time_raster_sink_f_sptr self) -> int"""
        return _qtgui_swig.time_raster_sink_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(time_raster_sink_f_sptr self) -> double"""
        return _qtgui_swig.time_raster_sink_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(time_raster_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.time_raster_sink_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(time_raster_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.time_raster_sink_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(time_raster_sink_f_sptr self) -> bool"""
        return _qtgui_swig.time_raster_sink_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(time_raster_sink_f_sptr self) -> bool"""
        return _qtgui_swig.time_raster_sink_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(time_raster_sink_f_sptr self, std::string level)"""
        return _qtgui_swig.time_raster_sink_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(time_raster_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""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) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""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) -> "int":
        r"""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: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(time_raster_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.time_raster_sink_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "gr::io_signature::sptr":
        r"""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) -> "long":
        r"""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) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""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: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(time_raster_sink_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.time_raster_sink_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(time_raster_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.time_raster_sink_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(time_raster_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.time_raster_sink_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(time_raster_sink_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.time_raster_sink_f_sptr_message_subscribers(self, which_port)

# Register time_raster_sink_f_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::freq_sink_c > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(freq_sink_c_sptr self) -> freq_sink_c_sptr
        __init__(freq_sink_c_sptr self, freq_sink_c p) -> freq_sink_c_sptr
        """
        _qtgui_swig.freq_sink_c_sptr_swiginit(self, _qtgui_swig.new_freq_sink_c_sptr(*args))

    def __deref__(self) -> "gr::qtgui::freq_sink_c *":
        r"""__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

    def make(self, fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::freq_sink_c::sptr":
        r"""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) -> "void":
        r"""exec_(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(freq_sink_c_sptr self) -> QWidget *"""
        return _qtgui_swig.freq_sink_c_sptr_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(freq_sink_c_sptr self) -> PyObject *"""
        return _qtgui_swig.freq_sink_c_sptr_pyqwidget(self)

    def set_fft_size(self, fftsize: "int const") -> "void":
        r"""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) -> "int":
        r"""fft_size(freq_sink_c_sptr self) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_fft_size(self)

    def set_fft_average(self, fftavg: "float const") -> "void":
        r"""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) -> "float":
        r"""fft_average(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_fft_average(self)

    def set_fft_window(self, win: "gr::filter::firdes::win_type const") -> "void":
        r"""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) -> "gr::filter::firdes::win_type":
        r"""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: "double const", bandwidth: "double const") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""set_title(freq_sink_c_sptr self, std::string const & title)"""
        return _qtgui_swig.freq_sink_c_sptr_set_title(self, title)

    def set_y_label(self, label: "std::string const &", unit: "std::string const &") -> "void":
        r"""set_y_label(freq_sink_c_sptr self, std::string const & label, std::string const & unit)"""
        return _qtgui_swig.freq_sink_c_sptr_set_y_label(self, label, unit)

    def set_line_label(self, which: "unsigned int", label: "std::string const &") -> "void":
        r"""set_line_label(freq_sink_c_sptr self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(freq_sink_c_sptr self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(freq_sink_c_sptr self, unsigned int which, int width)"""
        return _qtgui_swig.freq_sink_c_sptr_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(freq_sink_c_sptr self, unsigned int which, int style)"""
        return _qtgui_swig.freq_sink_c_sptr_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(freq_sink_c_sptr self, unsigned int which, int marker)"""
        return _qtgui_swig.freq_sink_c_sptr_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(freq_sink_c_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.freq_sink_c_sptr_set_line_alpha(self, which, alpha)

    def set_trigger_mode(self, *args, **kwargs) -> "void":
        r"""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) -> "std::string":
        r"""title(freq_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_title(self)

    def line_label(self, which: "unsigned int") -> "std::string":
        r"""line_label(freq_sink_c_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_line_label(self, which)

    def line_color(self, which: "unsigned int") -> "std::string":
        r"""line_color(freq_sink_c_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_line_color(self, which)

    def line_width(self, which: "unsigned int") -> "int":
        r"""line_width(freq_sink_c_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_line_width(self, which)

    def line_style(self, which: "unsigned int") -> "int":
        r"""line_style(freq_sink_c_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_line_style(self, which)

    def line_marker(self, which: "unsigned int") -> "int":
        r"""line_marker(freq_sink_c_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_line_marker(self, which)

    def line_alpha(self, which: "unsigned int") -> "double":
        r"""line_alpha(freq_sink_c_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.freq_sink_c_sptr_line_alpha(self, which)

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""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) -> "void":
        r"""clear_max_hold(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_clear_max_hold(self)

    def clear_min_hold(self) -> "void":
        r"""clear_min_hold(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_clear_min_hold(self)

    def disable_legend(self) -> "void":
        r"""disable_legend(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_disable_legend(self)

    def reset(self) -> "void":
        r"""reset(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_reset(self)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(freq_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.freq_sink_c_sptr_enable_axis_labels(self, en)
    d_qApplication = property(_qtgui_swig.freq_sink_c_sptr_d_qApplication_get, _qtgui_swig.freq_sink_c_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""history(freq_sink_c_sptr self) -> unsigned int"""
        return _qtgui_swig.freq_sink_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(freq_sink_c_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.freq_sink_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(freq_sink_c_sptr self, int multiple)"""
        return _qtgui_swig.freq_sink_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(freq_sink_c_sptr self) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(freq_sink_c_sptr self) -> double"""
        return _qtgui_swig.freq_sink_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(freq_sink_c_sptr self) -> uint64_t"""
        return _qtgui_swig.freq_sink_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(freq_sink_c_sptr self) -> uint64_t"""
        return _qtgui_swig.freq_sink_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(freq_sink_c_sptr self) -> bool"""
        return _qtgui_swig.freq_sink_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(freq_sink_c_sptr self) -> bool"""
        return _qtgui_swig.freq_sink_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(freq_sink_c_sptr self, std::string level)"""
        return _qtgui_swig.freq_sink_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(freq_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(freq_sink_c_sptr self) -> float"""
        return _qtgui_swig.freq_sink_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(freq_sink_c_sptr self)"""
        return _qtgui_swig.freq_sink_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(freq_sink_c_sptr self) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(freq_sink_c_sptr self) -> int"""
        return _qtgui_swig.freq_sink_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(freq_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(freq_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(freq_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.freq_sink_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(freq_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.freq_sink_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(freq_sink_c_sptr self) -> long"""
        return _qtgui_swig.freq_sink_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(freq_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(freq_sink_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.freq_sink_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(freq_sink_c_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.freq_sink_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(freq_sink_c_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.freq_sink_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(freq_sink_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.freq_sink_c_sptr_message_subscribers(self, which_port)

# Register freq_sink_c_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::freq_sink_f > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(freq_sink_f_sptr self) -> freq_sink_f_sptr
        __init__(freq_sink_f_sptr self, freq_sink_f p) -> freq_sink_f_sptr
        """
        _qtgui_swig.freq_sink_f_sptr_swiginit(self, _qtgui_swig.new_freq_sink_f_sptr(*args))

    def __deref__(self) -> "gr::qtgui::freq_sink_f *":
        r"""__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

    def make(self, fftsize: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::freq_sink_f::sptr":
        r"""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) -> "void":
        r"""exec_(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(freq_sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.freq_sink_f_sptr_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(freq_sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.freq_sink_f_sptr_pyqwidget(self)

    def set_fft_size(self, fftsize: "int const") -> "void":
        r"""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) -> "int":
        r"""fft_size(freq_sink_f_sptr self) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_fft_size(self)

    def set_fft_average(self, fftavg: "float const") -> "void":
        r"""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) -> "float":
        r"""fft_average(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_fft_average(self)

    def set_fft_window(self, win: "gr::filter::firdes::win_type const") -> "void":
        r"""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) -> "gr::filter::firdes::win_type":
        r"""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: "double const", bandwidth: "double const") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""set_title(freq_sink_f_sptr self, std::string const & title)"""
        return _qtgui_swig.freq_sink_f_sptr_set_title(self, title)

    def set_y_label(self, label: "std::string const &", unit: "std::string const &") -> "void":
        r"""set_y_label(freq_sink_f_sptr self, std::string const & label, std::string const & unit)"""
        return _qtgui_swig.freq_sink_f_sptr_set_y_label(self, label, unit)

    def set_line_label(self, which: "unsigned int", label: "std::string const &") -> "void":
        r"""set_line_label(freq_sink_f_sptr self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(freq_sink_f_sptr self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(freq_sink_f_sptr self, unsigned int which, int width)"""
        return _qtgui_swig.freq_sink_f_sptr_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(freq_sink_f_sptr self, unsigned int which, int style)"""
        return _qtgui_swig.freq_sink_f_sptr_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(freq_sink_f_sptr self, unsigned int which, int marker)"""
        return _qtgui_swig.freq_sink_f_sptr_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(freq_sink_f_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.freq_sink_f_sptr_set_line_alpha(self, which, alpha)

    def set_plot_pos_half(self, half: "bool") -> "void":
        r"""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) -> "void":
        r"""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) -> "std::string":
        r"""title(freq_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_title(self)

    def line_label(self, which: "unsigned int") -> "std::string":
        r"""line_label(freq_sink_f_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_line_label(self, which)

    def line_color(self, which: "unsigned int") -> "std::string":
        r"""line_color(freq_sink_f_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_line_color(self, which)

    def line_width(self, which: "unsigned int") -> "int":
        r"""line_width(freq_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_line_width(self, which)

    def line_style(self, which: "unsigned int") -> "int":
        r"""line_style(freq_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_line_style(self, which)

    def line_marker(self, which: "unsigned int") -> "int":
        r"""line_marker(freq_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_line_marker(self, which)

    def line_alpha(self, which: "unsigned int") -> "double":
        r"""line_alpha(freq_sink_f_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.freq_sink_f_sptr_line_alpha(self, which)

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""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) -> "void":
        r"""clear_max_hold(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_clear_max_hold(self)

    def clear_min_hold(self) -> "void":
        r"""clear_min_hold(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_clear_min_hold(self)

    def disable_legend(self) -> "void":
        r"""disable_legend(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_disable_legend(self)

    def reset(self) -> "void":
        r"""reset(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_reset(self)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(freq_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.freq_sink_f_sptr_enable_axis_labels(self, en)
    d_qApplication = property(_qtgui_swig.freq_sink_f_sptr_d_qApplication_get, _qtgui_swig.freq_sink_f_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""history(freq_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.freq_sink_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(freq_sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.freq_sink_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(freq_sink_f_sptr self, int multiple)"""
        return _qtgui_swig.freq_sink_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(freq_sink_f_sptr self) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(freq_sink_f_sptr self) -> double"""
        return _qtgui_swig.freq_sink_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(freq_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.freq_sink_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(freq_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.freq_sink_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(freq_sink_f_sptr self) -> bool"""
        return _qtgui_swig.freq_sink_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(freq_sink_f_sptr self) -> bool"""
        return _qtgui_swig.freq_sink_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(freq_sink_f_sptr self, std::string level)"""
        return _qtgui_swig.freq_sink_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(freq_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(freq_sink_f_sptr self) -> float"""
        return _qtgui_swig.freq_sink_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(freq_sink_f_sptr self)"""
        return _qtgui_swig.freq_sink_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(freq_sink_f_sptr self) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(freq_sink_f_sptr self) -> int"""
        return _qtgui_swig.freq_sink_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(freq_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(freq_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(freq_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.freq_sink_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(freq_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.freq_sink_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(freq_sink_f_sptr self) -> long"""
        return _qtgui_swig.freq_sink_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(freq_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.freq_sink_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(freq_sink_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.freq_sink_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(freq_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.freq_sink_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(freq_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.freq_sink_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(freq_sink_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.freq_sink_f_sptr_message_subscribers(self, which_port)

# Register freq_sink_f_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::const_sink_c > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(const_sink_c_sptr self) -> const_sink_c_sptr
        __init__(const_sink_c_sptr self, const_sink_c p) -> const_sink_c_sptr
        """
        _qtgui_swig.const_sink_c_sptr_swiginit(self, _qtgui_swig.new_const_sink_c_sptr(*args))

    def __deref__(self) -> "gr::qtgui::const_sink_c *":
        r"""__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

    def make(self, size: "int", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::const_sink_c::sptr":
        r"""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) -> "void":
        r"""exec_(const_sink_c_sptr self)"""
        return _qtgui_swig.const_sink_c_sptr_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(const_sink_c_sptr self) -> QWidget *"""
        return _qtgui_swig.const_sink_c_sptr_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(const_sink_c_sptr self) -> PyObject *"""
        return _qtgui_swig.const_sink_c_sptr_pyqwidget(self)

    def set_y_axis(self, min: "double", max: "double") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", label: "std::string const &") -> "void":
        r"""set_line_label(const_sink_c_sptr self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(const_sink_c_sptr self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(const_sink_c_sptr self, unsigned int which, int width)"""
        return _qtgui_swig.const_sink_c_sptr_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(const_sink_c_sptr self, unsigned int which, int style)"""
        return _qtgui_swig.const_sink_c_sptr_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(const_sink_c_sptr self, unsigned int which, int marker)"""
        return _qtgui_swig.const_sink_c_sptr_set_line_marker(self, which, marker)

    def set_nsamps(self, newsize: "int const") -> "void":
        r"""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: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(const_sink_c_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.const_sink_c_sptr_set_line_alpha(self, which, alpha)

    def set_trigger_mode(self, *args, **kwargs) -> "void":
        r"""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) -> "std::string":
        r"""title(const_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_title(self)

    def line_label(self, which: "unsigned int") -> "std::string":
        r"""line_label(const_sink_c_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_line_label(self, which)

    def line_color(self, which: "unsigned int") -> "std::string":
        r"""line_color(const_sink_c_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_line_color(self, which)

    def line_width(self, which: "unsigned int") -> "int":
        r"""line_width(const_sink_c_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.const_sink_c_sptr_line_width(self, which)

    def line_style(self, which: "unsigned int") -> "int":
        r"""line_style(const_sink_c_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.const_sink_c_sptr_line_style(self, which)

    def line_marker(self, which: "unsigned int") -> "int":
        r"""line_marker(const_sink_c_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.const_sink_c_sptr_line_marker(self, which)

    def line_alpha(self, which: "unsigned int") -> "double":
        r"""line_alpha(const_sink_c_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.const_sink_c_sptr_line_alpha(self, which)

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool") -> "void":
        r"""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: "bool") -> "void":
        r"""enable_grid(const_sink_c_sptr self, bool en)"""
        return _qtgui_swig.const_sink_c_sptr_enable_grid(self, en)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(const_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.const_sink_c_sptr_enable_axis_labels(self, en)

    def disable_legend(self) -> "void":
        r"""disable_legend(const_sink_c_sptr self)"""
        return _qtgui_swig.const_sink_c_sptr_disable_legend(self)

    def nsamps(self) -> "int":
        r"""nsamps(const_sink_c_sptr self) -> int"""
        return _qtgui_swig.const_sink_c_sptr_nsamps(self)

    def reset(self) -> "void":
        r"""reset(const_sink_c_sptr self)"""
        return _qtgui_swig.const_sink_c_sptr_reset(self)
    d_qApplication = property(_qtgui_swig.const_sink_c_sptr_d_qApplication_get, _qtgui_swig.const_sink_c_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""history(const_sink_c_sptr self) -> unsigned int"""
        return _qtgui_swig.const_sink_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(const_sink_c_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.const_sink_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(const_sink_c_sptr self, int multiple)"""
        return _qtgui_swig.const_sink_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(const_sink_c_sptr self) -> int"""
        return _qtgui_swig.const_sink_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(const_sink_c_sptr self) -> double"""
        return _qtgui_swig.const_sink_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(const_sink_c_sptr self) -> uint64_t"""
        return _qtgui_swig.const_sink_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(const_sink_c_sptr self) -> uint64_t"""
        return _qtgui_swig.const_sink_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(const_sink_c_sptr self) -> bool"""
        return _qtgui_swig.const_sink_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(const_sink_c_sptr self) -> bool"""
        return _qtgui_swig.const_sink_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(const_sink_c_sptr self, std::string level)"""
        return _qtgui_swig.const_sink_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(const_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(const_sink_c_sptr self) -> float"""
        return _qtgui_swig.const_sink_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(const_sink_c_sptr self)"""
        return _qtgui_swig.const_sink_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(const_sink_c_sptr self) -> int"""
        return _qtgui_swig.const_sink_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(const_sink_c_sptr self) -> int"""
        return _qtgui_swig.const_sink_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(const_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(const_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(const_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.const_sink_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(const_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.const_sink_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(const_sink_c_sptr self) -> long"""
        return _qtgui_swig.const_sink_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(const_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.const_sink_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(const_sink_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.const_sink_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(const_sink_c_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.const_sink_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(const_sink_c_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.const_sink_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(const_sink_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.const_sink_c_sptr_message_subscribers(self, which_port)

# Register const_sink_c_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::waterfall_sink_c > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(waterfall_sink_c_sptr self) -> waterfall_sink_c_sptr
        __init__(waterfall_sink_c_sptr self, waterfall_sink_c p) -> waterfall_sink_c_sptr
        """
        _qtgui_swig.waterfall_sink_c_sptr_swiginit(self, _qtgui_swig.new_waterfall_sink_c_sptr(*args))

    def __deref__(self) -> "gr::qtgui::waterfall_sink_c *":
        r"""__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

    def make(self, size: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::waterfall_sink_c::sptr":
        r"""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) -> "void":
        r"""exec_(waterfall_sink_c_sptr self)"""
        return _qtgui_swig.waterfall_sink_c_sptr_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(waterfall_sink_c_sptr self) -> QWidget *"""
        return _qtgui_swig.waterfall_sink_c_sptr_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(waterfall_sink_c_sptr self) -> PyObject *"""
        return _qtgui_swig.waterfall_sink_c_sptr_pyqwidget(self)

    def clear_data(self) -> "void":
        r"""clear_data(waterfall_sink_c_sptr self)"""
        return _qtgui_swig.waterfall_sink_c_sptr_clear_data(self)

    def set_fft_size(self, fftsize: "int const") -> "void":
        r"""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) -> "int":
        r"""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: "double const") -> "void":
        r"""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: "float const") -> "void":
        r"""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) -> "float":
        r"""fft_average(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_fft_average(self)

    def set_fft_window(self, win: "gr::filter::firdes::win_type const") -> "void":
        r"""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) -> "gr::filter::firdes::win_type":
        r"""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: "double const", bandwidth: "double const") -> "void":
        r"""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: "double const", max: "double const") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", line: "std::string const &") -> "void":
        r"""set_line_label(waterfall_sink_c_sptr self, unsigned 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: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(waterfall_sink_c_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_line_alpha(self, which, alpha)

    def set_color_map(self, which: "unsigned int", color: "int const") -> "void":
        r"""set_color_map(waterfall_sink_c_sptr self, unsigned int which, int const color)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_color_map(self, which, color)

    def title(self) -> "std::string":
        r"""title(waterfall_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_sptr_title(self)

    def line_label(self, which: "unsigned int") -> "std::string":
        r"""line_label(waterfall_sink_c_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_sptr_line_label(self, which)

    def line_alpha(self, which: "unsigned int") -> "double":
        r"""line_alpha(waterfall_sink_c_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.waterfall_sink_c_sptr_line_alpha(self, which)

    def color_map(self, which: "unsigned int") -> "int":
        r"""color_map(waterfall_sink_c_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_color_map(self, which)

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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) -> "void":
        r"""auto_scale(waterfall_sink_c_sptr self)"""
        return _qtgui_swig.waterfall_sink_c_sptr_auto_scale(self)

    def min_intensity(self, which: "unsigned int") -> "double":
        r"""min_intensity(waterfall_sink_c_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.waterfall_sink_c_sptr_min_intensity(self, which)

    def max_intensity(self, which: "unsigned int") -> "double":
        r"""max_intensity(waterfall_sink_c_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.waterfall_sink_c_sptr_max_intensity(self, which)

    def enable_menu(self, en: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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) -> "void":
        r"""disable_legend(waterfall_sink_c_sptr self)"""
        return _qtgui_swig.waterfall_sink_c_sptr_disable_legend(self)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(waterfall_sink_c_sptr self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_c_sptr_enable_axis_labels(self, en)
    d_qApplication = property(_qtgui_swig.waterfall_sink_c_sptr_d_qApplication_get, _qtgui_swig.waterfall_sink_c_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""history(waterfall_sink_c_sptr self) -> unsigned int"""
        return _qtgui_swig.waterfall_sink_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(waterfall_sink_c_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.waterfall_sink_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(waterfall_sink_c_sptr self, int multiple)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(waterfall_sink_c_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(waterfall_sink_c_sptr self) -> double"""
        return _qtgui_swig.waterfall_sink_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(waterfall_sink_c_sptr self) -> uint64_t"""
        return _qtgui_swig.waterfall_sink_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(waterfall_sink_c_sptr self) -> uint64_t"""
        return _qtgui_swig.waterfall_sink_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(waterfall_sink_c_sptr self) -> bool"""
        return _qtgui_swig.waterfall_sink_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(waterfall_sink_c_sptr self) -> bool"""
        return _qtgui_swig.waterfall_sink_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(waterfall_sink_c_sptr self, std::string level)"""
        return _qtgui_swig.waterfall_sink_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(waterfall_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(waterfall_sink_c_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(waterfall_sink_c_sptr self)"""
        return _qtgui_swig.waterfall_sink_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(waterfall_sink_c_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(waterfall_sink_c_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(waterfall_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(waterfall_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(waterfall_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(waterfall_sink_c_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(waterfall_sink_c_sptr self) -> long"""
        return _qtgui_swig.waterfall_sink_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(waterfall_sink_c_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(waterfall_sink_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.waterfall_sink_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(waterfall_sink_c_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(waterfall_sink_c_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(waterfall_sink_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.waterfall_sink_c_sptr_message_subscribers(self, which_port)

# Register waterfall_sink_c_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::waterfall_sink_f > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(waterfall_sink_f_sptr self) -> waterfall_sink_f_sptr
        __init__(waterfall_sink_f_sptr self, waterfall_sink_f p) -> waterfall_sink_f_sptr
        """
        _qtgui_swig.waterfall_sink_f_sptr_swiginit(self, _qtgui_swig.new_waterfall_sink_f_sptr(*args))

    def __deref__(self) -> "gr::qtgui::waterfall_sink_f *":
        r"""__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

    def make(self, size: "int", wintype: "int", fc: "double", bw: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::waterfall_sink_f::sptr":
        r"""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) -> "void":
        r"""exec_(waterfall_sink_f_sptr self)"""
        return _qtgui_swig.waterfall_sink_f_sptr_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(waterfall_sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.waterfall_sink_f_sptr_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(waterfall_sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.waterfall_sink_f_sptr_pyqwidget(self)

    def clear_data(self) -> "void":
        r"""clear_data(waterfall_sink_f_sptr self)"""
        return _qtgui_swig.waterfall_sink_f_sptr_clear_data(self)

    def set_fft_size(self, fftsize: "int const") -> "void":
        r"""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) -> "int":
        r"""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: "double const") -> "void":
        r"""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: "float const") -> "void":
        r"""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) -> "float":
        r"""fft_average(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_fft_average(self)

    def set_fft_window(self, win: "gr::filter::firdes::win_type const") -> "void":
        r"""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) -> "gr::filter::firdes::win_type":
        r"""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: "double const", bandwidth: "double const") -> "void":
        r"""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: "double const", max: "double const") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", line: "std::string const &") -> "void":
        r"""set_line_label(waterfall_sink_f_sptr self, unsigned 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: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(waterfall_sink_f_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_line_alpha(self, which, alpha)

    def set_color_map(self, which: "unsigned int", color: "int const") -> "void":
        r"""set_color_map(waterfall_sink_f_sptr self, unsigned 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: "bool") -> "void":
        r"""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) -> "std::string":
        r"""title(waterfall_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_sptr_title(self)

    def line_label(self, which: "unsigned int") -> "std::string":
        r"""line_label(waterfall_sink_f_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_sptr_line_label(self, which)

    def line_alpha(self, which: "unsigned int") -> "double":
        r"""line_alpha(waterfall_sink_f_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.waterfall_sink_f_sptr_line_alpha(self, which)

    def color_map(self, which: "unsigned int") -> "int":
        r"""color_map(waterfall_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_color_map(self, which)

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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) -> "void":
        r"""auto_scale(waterfall_sink_f_sptr self)"""
        return _qtgui_swig.waterfall_sink_f_sptr_auto_scale(self)

    def min_intensity(self, which: "unsigned int") -> "double":
        r"""min_intensity(waterfall_sink_f_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.waterfall_sink_f_sptr_min_intensity(self, which)

    def max_intensity(self, which: "unsigned int") -> "double":
        r"""max_intensity(waterfall_sink_f_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.waterfall_sink_f_sptr_max_intensity(self, which)

    def enable_menu(self, en: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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) -> "void":
        r"""disable_legend(waterfall_sink_f_sptr self)"""
        return _qtgui_swig.waterfall_sink_f_sptr_disable_legend(self)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(waterfall_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.waterfall_sink_f_sptr_enable_axis_labels(self, en)
    d_qApplication = property(_qtgui_swig.waterfall_sink_f_sptr_d_qApplication_get, _qtgui_swig.waterfall_sink_f_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""history(waterfall_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.waterfall_sink_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(waterfall_sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.waterfall_sink_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(waterfall_sink_f_sptr self, int multiple)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(waterfall_sink_f_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(waterfall_sink_f_sptr self) -> double"""
        return _qtgui_swig.waterfall_sink_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(waterfall_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.waterfall_sink_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(waterfall_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.waterfall_sink_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(waterfall_sink_f_sptr self) -> bool"""
        return _qtgui_swig.waterfall_sink_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(waterfall_sink_f_sptr self) -> bool"""
        return _qtgui_swig.waterfall_sink_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(waterfall_sink_f_sptr self, std::string level)"""
        return _qtgui_swig.waterfall_sink_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(waterfall_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(waterfall_sink_f_sptr self) -> float"""
        return _qtgui_swig.waterfall_sink_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(waterfall_sink_f_sptr self)"""
        return _qtgui_swig.waterfall_sink_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(waterfall_sink_f_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(waterfall_sink_f_sptr self) -> int"""
        return _qtgui_swig.waterfall_sink_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(waterfall_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(waterfall_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(waterfall_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(waterfall_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(waterfall_sink_f_sptr self) -> long"""
        return _qtgui_swig.waterfall_sink_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(waterfall_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.waterfall_sink_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(waterfall_sink_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.waterfall_sink_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(waterfall_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(waterfall_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(waterfall_sink_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.waterfall_sink_f_sptr_message_subscribers(self, which_port)

# Register waterfall_sink_f_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::histogram_sink_f > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(histogram_sink_f_sptr self) -> histogram_sink_f_sptr
        __init__(histogram_sink_f_sptr self, histogram_sink_f p) -> histogram_sink_f_sptr
        """
        _qtgui_swig.histogram_sink_f_sptr_swiginit(self, _qtgui_swig.new_histogram_sink_f_sptr(*args))

    def __deref__(self) -> "gr::qtgui::histogram_sink_f *":
        r"""__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

    def make(self, size: "int", bins: "int", xmin: "double", xmax: "double", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::histogram_sink_f::sptr":
        r"""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) -> "void":
        r"""exec_(histogram_sink_f_sptr self)"""
        return _qtgui_swig.histogram_sink_f_sptr_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(histogram_sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.histogram_sink_f_sptr_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(histogram_sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.histogram_sink_f_sptr_pyqwidget(self)

    def title(self) -> "std::string":
        r"""title(histogram_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_title(self)

    def line_label(self, which: "unsigned int") -> "std::string":
        r"""line_label(histogram_sink_f_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_line_label(self, which)

    def line_color(self, which: "unsigned int") -> "std::string":
        r"""line_color(histogram_sink_f_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_line_color(self, which)

    def line_width(self, which: "unsigned int") -> "int":
        r"""line_width(histogram_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_line_width(self, which)

    def line_style(self, which: "unsigned int") -> "int":
        r"""line_style(histogram_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_line_style(self, which)

    def line_marker(self, which: "unsigned int") -> "int":
        r"""line_marker(histogram_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_line_marker(self, which)

    def line_alpha(self, which: "unsigned int") -> "double":
        r"""line_alpha(histogram_sink_f_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.histogram_sink_f_sptr_line_alpha(self, which)

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""enable_accumulate(histogram_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_sptr_enable_accumulate(self, en)

    def enable_axis_labels(self, en: "bool"=True) -> "void":
        r"""enable_axis_labels(histogram_sink_f_sptr self, bool en=True)"""
        return _qtgui_swig.histogram_sink_f_sptr_enable_axis_labels(self, en)

    def autoscalex(self) -> "void":
        r"""autoscalex(histogram_sink_f_sptr self)"""
        return _qtgui_swig.histogram_sink_f_sptr_autoscalex(self)

    def nsamps(self) -> "int":
        r"""nsamps(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_nsamps(self)

    def bins(self) -> "int":
        r"""bins(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_bins(self)

    def reset(self) -> "void":
        r"""reset(histogram_sink_f_sptr self)"""
        return _qtgui_swig.histogram_sink_f_sptr_reset(self)
    d_qApplication = property(_qtgui_swig.histogram_sink_f_sptr_d_qApplication_get, _qtgui_swig.histogram_sink_f_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def set_y_axis(self, min: "double", max: "double") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", line: "std::string const &") -> "void":
        r"""set_line_label(histogram_sink_f_sptr self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(histogram_sink_f_sptr self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(histogram_sink_f_sptr self, unsigned int which, int width)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(histogram_sink_f_sptr self, unsigned int which, int style)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(histogram_sink_f_sptr self, unsigned int which, int marker)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(histogram_sink_f_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_line_alpha(self, which, alpha)

    def set_nsamps(self, newsize: "int const") -> "void":
        r"""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: "int const") -> "void":
        r"""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) -> "void":
        r"""disable_legend(histogram_sink_f_sptr self)"""
        return _qtgui_swig.histogram_sink_f_sptr_disable_legend(self)

    def history(self) -> "unsigned int":
        r"""history(histogram_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.histogram_sink_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(histogram_sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.histogram_sink_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(histogram_sink_f_sptr self, int multiple)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(histogram_sink_f_sptr self) -> double"""
        return _qtgui_swig.histogram_sink_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(histogram_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.histogram_sink_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(histogram_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.histogram_sink_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(histogram_sink_f_sptr self) -> bool"""
        return _qtgui_swig.histogram_sink_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(histogram_sink_f_sptr self) -> bool"""
        return _qtgui_swig.histogram_sink_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(histogram_sink_f_sptr self, std::string level)"""
        return _qtgui_swig.histogram_sink_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(histogram_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(histogram_sink_f_sptr self) -> float"""
        return _qtgui_swig.histogram_sink_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(histogram_sink_f_sptr self)"""
        return _qtgui_swig.histogram_sink_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(histogram_sink_f_sptr self) -> int"""
        return _qtgui_swig.histogram_sink_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(histogram_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(histogram_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(histogram_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.histogram_sink_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(histogram_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.histogram_sink_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(histogram_sink_f_sptr self) -> long"""
        return _qtgui_swig.histogram_sink_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(histogram_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.histogram_sink_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(histogram_sink_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.histogram_sink_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(histogram_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.histogram_sink_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(histogram_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.histogram_sink_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(histogram_sink_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.histogram_sink_f_sptr_message_subscribers(self, which_port)

# Register histogram_sink_f_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::number_sink > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(number_sink_sptr self) -> number_sink_sptr
        __init__(number_sink_sptr self, number_sink p) -> number_sink_sptr
        """
        _qtgui_swig.number_sink_sptr_swiginit(self, _qtgui_swig.new_number_sink_sptr(*args))

    def __deref__(self) -> "gr::qtgui::number_sink *":
        r"""__deref__(number_sink_sptr self) -> number_sink"""
        return _qtgui_swig.number_sink_sptr___deref__(self)
    __swig_destroy__ = _qtgui_swig.delete_number_sink_sptr

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

    def exec_(self) -> "void":
        r"""exec_(number_sink_sptr self)"""
        return _qtgui_swig.number_sink_sptr_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(number_sink_sptr self) -> QWidget *"""
        return _qtgui_swig.number_sink_sptr_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(number_sink_sptr self) -> PyObject *"""
        return _qtgui_swig.number_sink_sptr_pyqwidget(self)

    def set_update_time(self, t: "double") -> "void":
        r"""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: "float const") -> "void":
        r"""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: "gr::qtgui::graph_t const") -> "void":
        r"""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) -> "void":
        r"""
        set_color(number_sink_sptr self, unsigned int which, std::string const & min, std::string const & max)
        set_color(number_sink_sptr self, unsigned int which, int min, int max)
        """
        return _qtgui_swig.number_sink_sptr_set_color(self, *args)

    def set_label(self, which: "unsigned int", label: "std::string const &") -> "void":
        r"""set_label(number_sink_sptr self, unsigned int which, std::string const & label)"""
        return _qtgui_swig.number_sink_sptr_set_label(self, which, label)

    def set_min(self, which: "unsigned int", min: "float") -> "void":
        r"""set_min(number_sink_sptr self, unsigned int which, float min)"""
        return _qtgui_swig.number_sink_sptr_set_min(self, which, min)

    def set_max(self, which: "unsigned int", max: "float") -> "void":
        r"""set_max(number_sink_sptr self, unsigned int which, float max)"""
        return _qtgui_swig.number_sink_sptr_set_max(self, which, max)

    def set_title(self, title: "std::string const &") -> "void":
        r"""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: "unsigned int", unit: "std::string const &") -> "void":
        r"""set_unit(number_sink_sptr self, unsigned int which, std::string const & unit)"""
        return _qtgui_swig.number_sink_sptr_set_unit(self, which, unit)

    def set_factor(self, which: "unsigned int", factor: "float") -> "void":
        r"""set_factor(number_sink_sptr self, unsigned int which, float factor)"""
        return _qtgui_swig.number_sink_sptr_set_factor(self, which, factor)

    def average(self) -> "float":
        r"""average(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_average(self)

    def graph_type(self) -> "gr::qtgui::graph_t":
        r"""graph_type(number_sink_sptr self) -> gr::qtgui::graph_t"""
        return _qtgui_swig.number_sink_sptr_graph_type(self)

    def color_min(self, which: "unsigned int") -> "std::string":
        r"""color_min(number_sink_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.number_sink_sptr_color_min(self, which)

    def color_max(self, which: "unsigned int") -> "std::string":
        r"""color_max(number_sink_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.number_sink_sptr_color_max(self, which)

    def label(self, which: "unsigned int") -> "std::string":
        r"""label(number_sink_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.number_sink_sptr_label(self, which)

    def min(self, which: "unsigned int") -> "float":
        r"""min(number_sink_sptr self, unsigned int which) -> float"""
        return _qtgui_swig.number_sink_sptr_min(self, which)

    def max(self, which: "unsigned int") -> "float":
        r"""max(number_sink_sptr self, unsigned int which) -> float"""
        return _qtgui_swig.number_sink_sptr_max(self, which)

    def title(self) -> "std::string":
        r"""title(number_sink_sptr self) -> std::string"""
        return _qtgui_swig.number_sink_sptr_title(self)

    def unit(self, which: "unsigned int") -> "std::string":
        r"""unit(number_sink_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.number_sink_sptr_unit(self, which)

    def factor(self, which: "unsigned int") -> "float":
        r"""factor(number_sink_sptr self, unsigned int which) -> float"""
        return _qtgui_swig.number_sink_sptr_factor(self, which)

    def enable_menu(self, en: "bool"=True) -> "void":
        r"""enable_menu(number_sink_sptr self, bool en=True)"""
        return _qtgui_swig.number_sink_sptr_enable_menu(self, en)

    def enable_autoscale(self, en: "bool"=True) -> "void":
        r"""enable_autoscale(number_sink_sptr self, bool en=True)"""
        return _qtgui_swig.number_sink_sptr_enable_autoscale(self, en)

    def reset(self) -> "void":
        r"""reset(number_sink_sptr self)"""
        return _qtgui_swig.number_sink_sptr_reset(self)
    d_qApplication = property(_qtgui_swig.number_sink_sptr_d_qApplication_get, _qtgui_swig.number_sink_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""history(number_sink_sptr self) -> unsigned int"""
        return _qtgui_swig.number_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(number_sink_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.number_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(number_sink_sptr self, int multiple)"""
        return _qtgui_swig.number_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(number_sink_sptr self) -> int"""
        return _qtgui_swig.number_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(number_sink_sptr self) -> double"""
        return _qtgui_swig.number_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(number_sink_sptr self) -> uint64_t"""
        return _qtgui_swig.number_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(number_sink_sptr self) -> uint64_t"""
        return _qtgui_swig.number_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(number_sink_sptr self) -> bool"""
        return _qtgui_swig.number_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(number_sink_sptr self) -> bool"""
        return _qtgui_swig.number_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""nitems_written(number_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.number_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(number_sink_sptr self, std::string level)"""
        return _qtgui_swig.number_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(number_sink_sptr self) -> std::string"""
        return _qtgui_swig.number_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""min_noutput_items(number_sink_sptr self) -> int"""
        return _qtgui_swig.number_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""pc_noutput_items(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""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) -> "float":
        r"""pc_noutput_items_var(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""pc_work_time(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_throughput_avg(number_sink_sptr self) -> float"""
        return _qtgui_swig.number_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(number_sink_sptr self)"""
        return _qtgui_swig.number_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(number_sink_sptr self) -> int"""
        return _qtgui_swig.number_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(number_sink_sptr self) -> int"""
        return _qtgui_swig.number_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(number_sink_sptr self, int priority) -> int"""
        return _qtgui_swig.number_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(number_sink_sptr self) -> std::string"""
        return _qtgui_swig.number_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(number_sink_sptr self) -> std::string"""
        return _qtgui_swig.number_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(number_sink_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.number_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(number_sink_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.number_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(number_sink_sptr self) -> long"""
        return _qtgui_swig.number_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(number_sink_sptr self) -> std::string"""
        return _qtgui_swig.number_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(number_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.number_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(number_sink_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.number_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(number_sink_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.number_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(number_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.number_sink_sptr_message_subscribers(self, which_port)

# Register number_sink_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::ber_sink_b > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ber_sink_b_sptr self) -> ber_sink_b_sptr
        __init__(ber_sink_b_sptr self, ber_sink_b p) -> ber_sink_b_sptr
        """
        _qtgui_swig.ber_sink_b_sptr_swiginit(self, _qtgui_swig.new_ber_sink_b_sptr(*args))

    def __deref__(self) -> "gr::qtgui::ber_sink_b *":
        r"""__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

    def make(self, *args, **kwargs) -> "gr::qtgui::ber_sink_b::sptr":
        r"""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=std::vector< std::string >(), QWidget * parent=None) -> ber_sink_b_sptr"""
        return _qtgui_swig.ber_sink_b_sptr_make(self, *args, **kwargs)

    def exec_(self) -> "void":
        r"""exec_(ber_sink_b_sptr self)"""
        return _qtgui_swig.ber_sink_b_sptr_exec_(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(ber_sink_b_sptr self) -> PyObject *"""
        return _qtgui_swig.ber_sink_b_sptr_pyqwidget(self)

    def set_y_axis(self, min: "double", max: "double") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", label: "std::string const &") -> "void":
        r"""set_line_label(ber_sink_b_sptr self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(ber_sink_b_sptr self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(ber_sink_b_sptr self, unsigned int which, int width)"""
        return _qtgui_swig.ber_sink_b_sptr_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(ber_sink_b_sptr self, unsigned int which, int style)"""
        return _qtgui_swig.ber_sink_b_sptr_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(ber_sink_b_sptr self, unsigned int which, int marker)"""
        return _qtgui_swig.ber_sink_b_sptr_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(ber_sink_b_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.ber_sink_b_sptr_set_line_alpha(self, which, alpha)

    def title(self) -> "std::string":
        r"""title(ber_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_title(self)

    def line_label(self, which: "unsigned int") -> "std::string":
        r"""line_label(ber_sink_b_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_line_label(self, which)

    def line_color(self, which: "unsigned int") -> "std::string":
        r"""line_color(ber_sink_b_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_line_color(self, which)

    def line_width(self, which: "unsigned int") -> "int":
        r"""line_width(ber_sink_b_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_line_width(self, which)

    def line_style(self, which: "unsigned int") -> "int":
        r"""line_style(ber_sink_b_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_line_style(self, which)

    def line_marker(self, which: "unsigned int") -> "int":
        r"""line_marker(ber_sink_b_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_line_marker(self, which)

    def line_alpha(self, which: "unsigned int") -> "double":
        r"""line_alpha(ber_sink_b_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.ber_sink_b_sptr_line_alpha(self, which)

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool") -> "void":
        r"""enable_autoscale(ber_sink_b_sptr self, bool en)"""
        return _qtgui_swig.ber_sink_b_sptr_enable_autoscale(self, en)

    def nsamps(self) -> "int":
        r"""nsamps(ber_sink_b_sptr self) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_nsamps(self)
    d_qApplication = property(_qtgui_swig.ber_sink_b_sptr_d_qApplication_get, _qtgui_swig.ber_sink_b_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""history(ber_sink_b_sptr self) -> unsigned int"""
        return _qtgui_swig.ber_sink_b_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(ber_sink_b_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.ber_sink_b_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ber_sink_b_sptr self, int multiple)"""
        return _qtgui_swig.ber_sink_b_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ber_sink_b_sptr self) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ber_sink_b_sptr self) -> double"""
        return _qtgui_swig.ber_sink_b_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ber_sink_b_sptr self) -> uint64_t"""
        return _qtgui_swig.ber_sink_b_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ber_sink_b_sptr self) -> uint64_t"""
        return _qtgui_swig.ber_sink_b_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ber_sink_b_sptr self) -> bool"""
        return _qtgui_swig.ber_sink_b_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ber_sink_b_sptr self) -> bool"""
        return _qtgui_swig.ber_sink_b_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ber_sink_b_sptr self, std::string level)"""
        return _qtgui_swig.ber_sink_b_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ber_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(ber_sink_b_sptr self) -> float"""
        return _qtgui_swig.ber_sink_b_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(ber_sink_b_sptr self)"""
        return _qtgui_swig.ber_sink_b_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(ber_sink_b_sptr self) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ber_sink_b_sptr self) -> int"""
        return _qtgui_swig.ber_sink_b_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(ber_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ber_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ber_sink_b_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.ber_sink_b_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ber_sink_b_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.ber_sink_b_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ber_sink_b_sptr self) -> long"""
        return _qtgui_swig.ber_sink_b_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(ber_sink_b_sptr self) -> std::string"""
        return _qtgui_swig.ber_sink_b_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ber_sink_b_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.ber_sink_b_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ber_sink_b_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.ber_sink_b_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ber_sink_b_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.ber_sink_b_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ber_sink_b_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.ber_sink_b_sptr_message_subscribers(self, which_port)

# Register ber_sink_b_sptr in _qtgui_swig:
_qtgui_swig.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):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::vector_sink_f > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(vector_sink_f_sptr self) -> vector_sink_f_sptr
        __init__(vector_sink_f_sptr self, vector_sink_f p) -> vector_sink_f_sptr
        """
        _qtgui_swig.vector_sink_f_sptr_swiginit(self, _qtgui_swig.new_vector_sink_f_sptr(*args))

    def __deref__(self) -> "gr::qtgui::vector_sink_f *":
        r"""__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

    def make(self, vlen: "unsigned int", x_start: "double", x_step: "double", x_axis_label: "std::string const &", y_axis_label: "std::string const &", name: "std::string const &", nconnections: "int"=1, parent: "QWidget *"=None) -> "gr::qtgui::vector_sink_f::sptr":
        r"""make(vector_sink_f_sptr self, unsigned 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) -> "void":
        r"""exec_(vector_sink_f_sptr self)"""
        return _qtgui_swig.vector_sink_f_sptr_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(vector_sink_f_sptr self) -> QWidget *"""
        return _qtgui_swig.vector_sink_f_sptr_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(vector_sink_f_sptr self) -> PyObject *"""
        return _qtgui_swig.vector_sink_f_sptr_pyqwidget(self)

    def vlen(self) -> "unsigned int":
        r"""vlen(vector_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.vector_sink_f_sptr_vlen(self)

    def set_vec_average(self, avg: "float const") -> "void":
        r"""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) -> "float":
        r"""vec_average(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_vec_average(self)

    def set_x_axis(self, start: "double const", step: "double const") -> "void":
        r"""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: "double", max: "double") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "double") -> "void":
        r"""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: "std::string const &") -> "void":
        r"""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: "unsigned int", label: "std::string const &") -> "void":
        r"""set_line_label(vector_sink_f_sptr self, unsigned 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: "unsigned int", color: "std::string const &") -> "void":
        r"""set_line_color(vector_sink_f_sptr self, unsigned 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: "unsigned int", width: "int") -> "void":
        r"""set_line_width(vector_sink_f_sptr self, unsigned int which, int width)"""
        return _qtgui_swig.vector_sink_f_sptr_set_line_width(self, which, width)

    def set_line_style(self, which: "unsigned int", style: "int") -> "void":
        r"""set_line_style(vector_sink_f_sptr self, unsigned int which, int style)"""
        return _qtgui_swig.vector_sink_f_sptr_set_line_style(self, which, style)

    def set_line_marker(self, which: "unsigned int", marker: "int") -> "void":
        r"""set_line_marker(vector_sink_f_sptr self, unsigned int which, int marker)"""
        return _qtgui_swig.vector_sink_f_sptr_set_line_marker(self, which, marker)

    def set_line_alpha(self, which: "unsigned int", alpha: "double") -> "void":
        r"""set_line_alpha(vector_sink_f_sptr self, unsigned int which, double alpha)"""
        return _qtgui_swig.vector_sink_f_sptr_set_line_alpha(self, which, alpha)

    def title(self) -> "std::string":
        r"""title(vector_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_title(self)

    def line_label(self, which: "unsigned int") -> "std::string":
        r"""line_label(vector_sink_f_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_line_label(self, which)

    def line_color(self, which: "unsigned int") -> "std::string":
        r"""line_color(vector_sink_f_sptr self, unsigned int which) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_line_color(self, which)

    def line_width(self, which: "unsigned int") -> "int":
        r"""line_width(vector_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_line_width(self, which)

    def line_style(self, which: "unsigned int") -> "int":
        r"""line_style(vector_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_line_style(self, which)

    def line_marker(self, which: "unsigned int") -> "int":
        r"""line_marker(vector_sink_f_sptr self, unsigned int which) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_line_marker(self, which)

    def line_alpha(self, which: "unsigned int") -> "double":
        r"""line_alpha(vector_sink_f_sptr self, unsigned int which) -> double"""
        return _qtgui_swig.vector_sink_f_sptr_line_alpha(self, which)

    def set_size(self, width: "int", height: "int") -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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: "bool"=True) -> "void":
        r"""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) -> "void":
        r"""clear_max_hold(vector_sink_f_sptr self)"""
        return _qtgui_swig.vector_sink_f_sptr_clear_max_hold(self)

    def clear_min_hold(self) -> "void":
        r"""clear_min_hold(vector_sink_f_sptr self)"""
        return _qtgui_swig.vector_sink_f_sptr_clear_min_hold(self)

    def reset(self) -> "void":
        r"""reset(vector_sink_f_sptr self)"""
        return _qtgui_swig.vector_sink_f_sptr_reset(self)
    d_qApplication = property(_qtgui_swig.vector_sink_f_sptr_d_qApplication_get, _qtgui_swig.vector_sink_f_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""history(vector_sink_f_sptr self) -> unsigned int"""
        return _qtgui_swig.vector_sink_f_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        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: "int") -> "unsigned int":
        r"""sample_delay(vector_sink_f_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.vector_sink_f_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(vector_sink_f_sptr self, int multiple)"""
        return _qtgui_swig.vector_sink_f_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(vector_sink_f_sptr self) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(vector_sink_f_sptr self) -> double"""
        return _qtgui_swig.vector_sink_f_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(vector_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.vector_sink_f_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(vector_sink_f_sptr self) -> uint64_t"""
        return _qtgui_swig.vector_sink_f_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(vector_sink_f_sptr self) -> bool"""
        return _qtgui_swig.vector_sink_f_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(vector_sink_f_sptr self) -> bool"""
        return _qtgui_swig.vector_sink_f_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""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: "unsigned int") -> "uint64_t":
        r"""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 set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(vector_sink_f_sptr self, std::string level)"""
        return _qtgui_swig.vector_sink_f_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(vector_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""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: "int") -> "void":
        r"""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) -> "void":
        r"""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) -> "bool":
        r"""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: "int") -> "void":
        r"""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) -> "int":
        r"""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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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: "int") -> "long":
        r"""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) -> "void":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""pc_nproduced(vector_sink_f_sptr self) -> float"""
        return _qtgui_swig.vector_sink_f_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""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) -> "float":
        r"""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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "std::vector< float,std::allocator< float > >":
        r"""
        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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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) -> "float":
        r"""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: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""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) -> "void":
        r"""unset_processor_affinity(vector_sink_f_sptr self)"""
        return _qtgui_swig.vector_sink_f_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""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) -> "int":
        r"""active_thread_priority(vector_sink_f_sptr self) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(vector_sink_f_sptr self) -> int"""
        return _qtgui_swig.vector_sink_f_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""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) -> "std::string":
        r"""name(vector_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(vector_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(vector_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.vector_sink_f_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(vector_sink_f_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.vector_sink_f_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(vector_sink_f_sptr self) -> long"""
        return _qtgui_swig.vector_sink_f_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""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: "int", noutputs: "int") -> "bool":
        r"""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) -> "std::string":
        r"""alias(vector_sink_f_sptr self) -> std::string"""
        return _qtgui_swig.vector_sink_f_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""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: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(vector_sink_f_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.vector_sink_f_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(vector_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.vector_sink_f_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(vector_sink_f_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.vector_sink_f_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(vector_sink_f_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.vector_sink_f_sptr_message_subscribers(self, which_port)

# Register vector_sink_f_sptr in _qtgui_swig:
_qtgui_swig.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;

class edit_box_msg_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::qtgui::edit_box_msg > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(edit_box_msg_sptr self) -> edit_box_msg_sptr
        __init__(edit_box_msg_sptr self, edit_box_msg p) -> edit_box_msg_sptr
        """
        _qtgui_swig.edit_box_msg_sptr_swiginit(self, _qtgui_swig.new_edit_box_msg_sptr(*args))

    def __deref__(self) -> "gr::qtgui::edit_box_msg *":
        r"""__deref__(edit_box_msg_sptr self) -> edit_box_msg"""
        return _qtgui_swig.edit_box_msg_sptr___deref__(self)
    __swig_destroy__ = _qtgui_swig.delete_edit_box_msg_sptr

    def make(self, *args, **kwargs) -> "gr::qtgui::edit_box_msg::sptr":
        r"""make(edit_box_msg_sptr self, gr::qtgui::data_type_t type, std::string const & value="", std::string const & label="", bool is_pair=True, bool is_static=True, std::string const & key="", QWidget * parent=None) -> edit_box_msg_sptr"""
        return _qtgui_swig.edit_box_msg_sptr_make(self, *args, **kwargs)

    def exec_(self) -> "void":
        r"""exec_(edit_box_msg_sptr self)"""
        return _qtgui_swig.edit_box_msg_sptr_exec_(self)

    def qwidget(self) -> "QWidget *":
        r"""qwidget(edit_box_msg_sptr self) -> QWidget *"""
        return _qtgui_swig.edit_box_msg_sptr_qwidget(self)

    def pyqwidget(self) -> "PyObject *":
        r"""pyqwidget(edit_box_msg_sptr self) -> PyObject *"""
        return _qtgui_swig.edit_box_msg_sptr_pyqwidget(self)
    d_qApplication = property(_qtgui_swig.edit_box_msg_sptr_d_qApplication_get, _qtgui_swig.edit_box_msg_sptr_d_qApplication_set, doc=r"""d_qApplication : p.QApplication""")

    def history(self) -> "unsigned int":
        r"""history(edit_box_msg_sptr self) -> unsigned int"""
        return _qtgui_swig.edit_box_msg_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(edit_box_msg_sptr self, int which, int delay)
        declare_sample_delay(edit_box_msg_sptr self, unsigned int delay)
        """
        return _qtgui_swig.edit_box_msg_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(edit_box_msg_sptr self, int which) -> unsigned int"""
        return _qtgui_swig.edit_box_msg_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(edit_box_msg_sptr self, int multiple)"""
        return _qtgui_swig.edit_box_msg_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(edit_box_msg_sptr self) -> int"""
        return _qtgui_swig.edit_box_msg_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(edit_box_msg_sptr self) -> double"""
        return _qtgui_swig.edit_box_msg_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(edit_box_msg_sptr self) -> uint64_t"""
        return _qtgui_swig.edit_box_msg_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(edit_box_msg_sptr self) -> uint64_t"""
        return _qtgui_swig.edit_box_msg_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(edit_box_msg_sptr self) -> bool"""
        return _qtgui_swig.edit_box_msg_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(edit_box_msg_sptr self) -> bool"""
        return _qtgui_swig.edit_box_msg_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(edit_box_msg_sptr self, unsigned int which_input) -> uint64_t"""
        return _qtgui_swig.edit_box_msg_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(edit_box_msg_sptr self, unsigned int which_output) -> uint64_t"""
        return _qtgui_swig.edit_box_msg_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(edit_box_msg_sptr self, std::string level)"""
        return _qtgui_swig.edit_box_msg_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(edit_box_msg_sptr self) -> std::string"""
        return _qtgui_swig.edit_box_msg_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(edit_box_msg_sptr self) -> int"""
        return _qtgui_swig.edit_box_msg_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(edit_box_msg_sptr self, int m)"""
        return _qtgui_swig.edit_box_msg_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(edit_box_msg_sptr self)"""
        return _qtgui_swig.edit_box_msg_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(edit_box_msg_sptr self) -> bool"""
        return _qtgui_swig.edit_box_msg_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(edit_box_msg_sptr self, int m)"""
        return _qtgui_swig.edit_box_msg_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(edit_box_msg_sptr self) -> int"""
        return _qtgui_swig.edit_box_msg_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(edit_box_msg_sptr self, int i) -> long"""
        return _qtgui_swig.edit_box_msg_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(edit_box_msg_sptr self, long max_output_buffer)
        set_max_output_buffer(edit_box_msg_sptr self, int port, long max_output_buffer)
        """
        return _qtgui_swig.edit_box_msg_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(edit_box_msg_sptr self, int i) -> long"""
        return _qtgui_swig.edit_box_msg_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(edit_box_msg_sptr self, long min_output_buffer)
        set_min_output_buffer(edit_box_msg_sptr self, int port, long min_output_buffer)
        """
        return _qtgui_swig.edit_box_msg_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(edit_box_msg_sptr self) -> float"""
        return _qtgui_swig.edit_box_msg_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(edit_box_msg_sptr self) -> float"""
        return _qtgui_swig.edit_box_msg_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(edit_box_msg_sptr self) -> float"""
        return _qtgui_swig.edit_box_msg_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(edit_box_msg_sptr self) -> float"""
        return _qtgui_swig.edit_box_msg_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(edit_box_msg_sptr self) -> float"""
        return _qtgui_swig.edit_box_msg_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(edit_box_msg_sptr self) -> float"""
        return _qtgui_swig.edit_box_msg_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(edit_box_msg_sptr self, int which) -> float
        pc_input_buffers_full(edit_box_msg_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.edit_box_msg_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(edit_box_msg_sptr self, int which) -> float
        pc_input_buffers_full_avg(edit_box_msg_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.edit_box_msg_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(edit_box_msg_sptr self, int which) -> float
        pc_input_buffers_full_var(edit_box_msg_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.edit_box_msg_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(edit_box_msg_sptr self, int which) -> float
        pc_output_buffers_full(edit_box_msg_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.edit_box_msg_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(edit_box_msg_sptr self, int which) -> float
        pc_output_buffers_full_avg(edit_box_msg_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.edit_box_msg_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(edit_box_msg_sptr self, int which) -> float
        pc_output_buffers_full_var(edit_box_msg_sptr self) -> pmt_vector_float
        """
        return _qtgui_swig.edit_box_msg_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(edit_box_msg_sptr self) -> float"""
        return _qtgui_swig.edit_box_msg_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(edit_box_msg_sptr self) -> float"""
        return _qtgui_swig.edit_box_msg_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(edit_box_msg_sptr self) -> float"""
        return _qtgui_swig.edit_box_msg_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(edit_box_msg_sptr self) -> float"""
        return _qtgui_swig.edit_box_msg_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(edit_box_msg_sptr self) -> float"""
        return _qtgui_swig.edit_box_msg_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(edit_box_msg_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _qtgui_swig.edit_box_msg_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(edit_box_msg_sptr self)"""
        return _qtgui_swig.edit_box_msg_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(edit_box_msg_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _qtgui_swig.edit_box_msg_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(edit_box_msg_sptr self) -> int"""
        return _qtgui_swig.edit_box_msg_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(edit_box_msg_sptr self) -> int"""
        return _qtgui_swig.edit_box_msg_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(edit_box_msg_sptr self, int priority) -> int"""
        return _qtgui_swig.edit_box_msg_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(edit_box_msg_sptr self) -> std::string"""
        return _qtgui_swig.edit_box_msg_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(edit_box_msg_sptr self) -> std::string"""
        return _qtgui_swig.edit_box_msg_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(edit_box_msg_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.edit_box_msg_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(edit_box_msg_sptr self) -> io_signature_sptr"""
        return _qtgui_swig.edit_box_msg_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(edit_box_msg_sptr self) -> long"""
        return _qtgui_swig.edit_box_msg_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(edit_box_msg_sptr self) -> basic_block_sptr"""
        return _qtgui_swig.edit_box_msg_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(edit_box_msg_sptr self, int ninputs, int noutputs) -> bool"""
        return _qtgui_swig.edit_box_msg_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(edit_box_msg_sptr self) -> std::string"""
        return _qtgui_swig.edit_box_msg_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(edit_box_msg_sptr self, std::string name)"""
        return _qtgui_swig.edit_box_msg_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(edit_box_msg_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _qtgui_swig.edit_box_msg_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(edit_box_msg_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.edit_box_msg_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(edit_box_msg_sptr self) -> swig_pmt_ptr"""
        return _qtgui_swig.edit_box_msg_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(edit_box_msg_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _qtgui_swig.edit_box_msg_sptr_message_subscribers(self, which_port)

# Register edit_box_msg_sptr in _qtgui_swig:
_qtgui_swig.edit_box_msg_sptr_swigregister(edit_box_msg_sptr)


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



