Connect the signals with the slots to make the ui functional

        :returns: None
        :rtype: None
        :raises: None
180581
def setup_signals(self, ):
        
        self.showfilter_tb.toggled.connect(self.switch_showfilter_icon)
        self.addnew_tb.clicked.connect(self.open_addnew_win)
        self.search_le.editingFinished.connect(self.update_filter)
        for cb in (self.loaded_checkb, self.unloaded_checkb, self.imported_checkb, self.empty_checkb,
                   self.newest_checkb, self.old_checkb, self.alien_checkb):
            cb.toggled.connect(self.update_filter)
567759
def listens_to(name, sender=None, weak=True):
    
    def decorator(f):
        if sender:
            return signal(name).connect(f, sender=sender, weak=weak)
        return signal(name).connect(f, weak=weak)
    return decorator
1087453
def connect_after(self, slot, *extra_args):
        
        slot = Slot(slot, *extra_args)
        self._after_functions.add(slot)
1286578
def setup_ui(self, ):
        
        grid = QtGui.QGridLayout(self)
        grid.setContentsMargins(0, 0, 0, 0)
        self.setLayout(grid)
691622
def _do_connection(self, wgt, sig, func):
        
        #new style  (we use this)
        #self.btn_name.clicked.connect(self.on_btn_name_clicked)
        #old style
        #self.connect(self.btn_name, SIGNAL('clicked()'), self.on_btn_name_clicked)

        if hasattr(self, wgt):
            wgtobj = getattr(self, wgt)
            if hasattr(wgtobj, sig):
                sigobj = getattr(wgtobj, sig)
                if isinstance(sigobj, Signal):
                    sigobj.connect(func)
                    return 0
        return 1
1076531
def _connect_func(builder, obj, signal_name, handler_name,
                  connect_object, flags, cls):
    ''''''

    if connect_object is None:
        extra = ()
    else:
        extra = (connect_object,)

    # The handler name refers to an attribute on the template instance,
    # so ask GtkBuilder for the template instance
    template_inst = builder.get_object(cls.__gtype_name__)

    if template_inst is None:  # This should never happen
        errmsg = "Internal error: cannot find template instance! obj: %s; " \
                 "signal: %s; handler: %s; connect_obj: %s; class: %s" % \
                 (obj, signal_name, handler_name, connect_object, cls)
        warnings.warn(errmsg, GtkTemplateWarning)
        return

    handler = getattr(template_inst, handler_name)

    if flags == GObject.ConnectFlags.AFTER:
        obj.connect_after(signal_name, handler, *extra)
    else:
        obj.connect(signal_name, handler, *extra)

    template_inst.__connected_template_signals__.add(handler_name)
234512
def connect_any_signal_changed(self, function):
        
        
        # loop over all top level parameters
        for i in range(self._widget.topLevelItemCount()):

            # make sure there is only one connection!
            try:
                self._widget.topLevelItem(i).param.sigTreeStateChanged.connect(
                                  function, type=_g.QtCore.Qt.UniqueConnection)
            except:
                pass
            
        return self
982931
def setup_user_signals(self, ):
        
        log.debug("Setting up user page signals.")
        self.user_task_view_pb.clicked.connect(self.user_view_task)
        self.user_prj_view_pb.clicked.connect(self.user_view_prj)
        self.user_prj_add_pb.clicked.connect(self.user_add_prj)
        self.user_prj_remove_pb.clicked.connect(self.user_remove_prj)
        self.user_username_le.editingFinished.connect(self.user_save)
        self.user_first_le.editingFinished.connect(self.user_save)
        self.user_last_le.editingFinished.connect(self.user_save)
        self.user_email_le.editingFinished.connect(self.user_save)
1222901
def init_signal(self):
        """"""
        signal.signal(signal.SIGINT, lambda sig, frame: self.exit(-2))
        # need a timer, so that QApplication doesn't block until a real
        # Qt event fires (can require mouse movement)
        # timer trick from http://stackoverflow.com/q/4938723/938949
        timer = QtCore.QTimer()
        # Let the interpreter run each 200 ms:
        timer.timeout.connect(lambda: None)
        timer.start(200)
        # hold onto ref, so the timer doesn't get cleaned up
        self._sigint_timer = timer
23043
def add_signal(self, signal):
        """"""
        self.__signals.append(signal)
        if self.__connected:
            # Connects signal if the current state is "connected"
            self.__connect_signal(signal)
377169
def connect(self, interface, event, object_path, handler):
        
        if object_path:
            def callback(connection, sender_name, object_path,
                         interface_name, signal_name, parameters):
                return handler(*unpack_variant(parameters))
        else:
            def callback(connection, sender_name, object_path,
                         interface_name, signal_name, parameters):
                return handler(object_path, *unpack_variant(parameters))
        return self.connection.signal_subscribe(
            self.bus_name,
            interface,
            event,
            object_path,
            None,
            Gio.DBusSignalFlags.NONE,
            callback,
        )
229218
def connect(self, signal, **kwargs):
        """"""
        signal.connect(self, **kwargs)
        self.connections.append((signal, kwargs))
509883
def register_signal(alias: str, signal: pyqtSignal):
        
        if SignalDispatcher.signal_alias_exists(alias):
            raise SignalDispatcherError('Alias "' + alias + '" for signal already exists!')

        SignalDispatcher.signals[alias] = signal
52966
def connect(self, their_unl, events, force_master=1, hairpin=1,
                nonce="0" * 64):
        
        parms = (their_unl, events, force_master, hairpin, nonce)
        t = Thread(target=self.connect_handler, args=parms)
        t.start()
        self.unl_threads.append(t)
265037
def dispatch():
        
        aliases = SignalDispatcher.signals.keys()

        for alias in aliases:
            handlers = SignalDispatcher.handlers.get(alias)
            signal = SignalDispatcher.signals.get(alias)

            if signal is None or handlers.__len__() == 0:
                continue

            for handler in handlers:
                signal.connect(handler)
528772
def connect_signal_changed(self, name, function):
        
        x = self._find_parameter(name.split("/"))

        # if it pooped.
        if x==None: return None

        # connect it
        x.sigValueChanged.connect(function)
        
        # Keep track of the functions
        if name in self._connection_lists: self._connection_lists[name].append(function)
        else:                              self._connection_lists[name] = [function]

        return self
438053
def _connect_signals(self, model):
        
        for signal in self._signals:
            receiver = self._signals[signal]
            signal.connect(receiver, sender=model, dispatch_uid=self._dispatch_uid(signal, model))