Enable or Disable non-filter listeners for this record.
494053
public Object[] setEnableNonFilter(Object[] rgobjEnable, boolean bHasNext, boolean bBreak, boolean bAfterRequery, boolean bSelectEOF, boolean bFieldListeners)
    {
        boolean bEnable = (rgobjEnable == null) ? false : true;
        if (bFieldListeners)
        {
            if (rgobjEnable == null)
                rgobjEnable = this.setEnableFieldListeners(bEnable);
            else
                this.setEnableFieldListeners(rgobjEnable);
        }
        else
        {
            if (rgobjEnable == null)
                rgobjEnable = new Object[0];
        }
        FileListener listener = this.getListener();
        int iCount = this.getFieldCount();
        while (listener != null)
        {
            if (!(listener instanceof org.jbundle.base.db.filter.FileFilter))
            {
                if (!bEnable)
                {
                    rgobjEnable = Utility.growArray(rgobjEnable, iCount + 1, 8);
                    if (listener.isEnabledListener())
                        rgobjEnable[iCount] = Boolean.TRUE;
                    else
                        rgobjEnable[iCount] = Boolean.FALSE;
                    listener.setEnabledListener(bEnable);
                }
                else
                {   // Enable
                    boolean bEnableThis = true;
                    if (iCount < rgobjEnable.length)
                        if (rgobjEnable[iCount] != null)
                            bEnableThis = ((Boolean)rgobjEnable[iCount]).booleanValue();
                    listener.setEnabledListener(bEnableThis);
                }
                iCount++;
            }
            listener = (FileListener)listener.getNextListener();
        }
        if (bEnable)
        {
            if (bAfterRequery)
                this.handleRecordChange(null, DBConstants.AFTER_REQUERY_TYPE, true);
            if (bBreak)
                this.handleRecordChange(null, DBConstants.CONTROL_BREAK_TYPE, true);
            if (bHasNext)
            {
                this.handleValidRecord(true);
                this.handleRecordChange(null, DBConstants.MOVE_NEXT_TYPE, true);
            }
            if (bSelectEOF)
                this.handleRecordChange(null, DBConstants.SELECT_EOF_TYPE, true);
            if (this.getTable().getCurrentTable().getRecord() != this)
            {   // Special logic - match listeners on current record (if shared)
                boolean bCloneListeners = false;
                boolean bMatchEnabledState = true;
                boolean bSyncReferenceFields = false;
                boolean bMatchSelectedState = true;
                this.matchListeners(this.getTable().getCurrentTable().getRecord(), bCloneListeners, bMatchEnabledState, bSyncReferenceFields, bMatchSelectedState, true);
            }
        }
            
        return rgobjEnable;
    }
1166942
public void addListeners()
    {
        super.addListeners();
        this.getMainRecord().getField(Appointment.CALENDAR_CATEGORY_ID).addListener(new InitFieldHandler(this.getRecord(CalendarControl.CALENDAR_CONTROL_FILE).getField(CalendarControl.APPOINTMENT_CATEGORY_ID)));
    }
1101334
public void addListeners()
    {
        super.addListeners();
        
        if (m_recHeader != null)
            this.getMainRecord().addListener(new ProjectTaskParentFilter(m_recHeader));
        
        this.setEditing(true);
        this.getMainRecord().addListener(new FileFilter(null)
        {
            public boolean doLocalCriteria(StringBuffer strbFilter, boolean bIncludeFileName, Vector<BaseField> vParamList)
            {   // Between start and end dates? (Defaults to Currentdate thru +1 year)
                boolean bDontSkip = true;
                if (this.getOwner().getField(ProjectTask.START_DATE_TIME).isNull())
                    bDontSkip = false;
                if (bDontSkip)
                    return super.doLocalCriteria(strbFilter, bIncludeFileName, vParamList);    // Dont skip this record
                else
                    return false;   // Skip this one
            }
                });
    }
1228788
public void disable() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "disable chain " + this);
        }
        enabled = false;
    }
709048
public void removeSelectionChangedListener(
			ISelectionChangedListener listener)
	{
		if (fOutlineViewer != null)
		{
			fOutlineViewer.removeSelectionChangedListener(listener);
		} else
		{
			fSelectionChangedListeners.remove(listener);
		}
	}
287741
public function disableRevisionListener()
    {
        foreach ($this->em->getEventManager()->getListeners() as $event => $listeners) {
            foreach ($listeners as $hash => $listener) {
                if ($listener instanceof RevisionListener) {
                    $this->revisionListener = $listener;
                    break 2;
                }
            }
        }

        if ($this->revisionListener) {
            $this->revisionListener->setActive(false);
        }
    }
1166459
public void addListeners()
    {
        // This beginning code is a trick to make the grid screen think that a zero record is the header.
        this.setProperty("fakeHeader", DBConstants.FALSE);
        if (m_recHeader != null)
            if ((m_recHeader.getEditMode() == DBConstants.EDIT_ADD) || (m_recHeader.getEditMode() == DBConstants.EDIT_NONE))
                if (this.getProperty(DBParams.HEADER_OBJECT_ID) == null)
                {
                    this.setProperty("fakeHeader", DBConstants.TRUE);
                    this.setProperty(DBParams.HEADER_OBJECT_ID, "0");
                    if (m_recHeader.getCounterField() != null)
                        if (m_recHeader.getCounterField().getDefault() == null)
                    {
                        m_recHeader.getCounterField().setDefault(new Integer(0)); // This will guarantee that the sub record's parent field is non-null
                        try {
                            m_recHeader.addNew();
                        } catch (DBException ex) {
                        }
                    }
                }
        super.addListeners();
    }
1024815
public static synchronized void disable() {
        if (!enabled) {
            return;
        }
        RxJavaPlugins.setOnObservableAssembly(oldOnObservableAssembly);
        oldOnObservableAssembly = null;
        RxJavaPlugins.setOnConnectableObservableAssembly(oldOnConnectableObservableAssembly);
        oldOnConnectableObservableAssembly = null;
        RxJavaPlugins.setOnCompletableAssembly(oldOnCompletableAssembly);
        oldOnCompletableAssembly = null;
        RxJavaPlugins.setOnSingleAssembly(oldOnSingleAssembly);
        oldOnSingleAssembly = null;
        RxJavaPlugins.setOnMaybeAssembly(oldOnMaybeAssembly);
        oldOnMaybeAssembly = null;
        RxJavaPlugins.setOnFlowableAssembly(oldOnFlowableAssembly);
        oldOnFlowableAssembly = null;
        RxJavaPlugins.setOnConnectableFlowableAssembly(oldOnConnectableFlowableAssembly);
        oldOnConnectableFlowableAssembly = null;
        RxJavaPlugins.setOnParallelAssembly(oldOnParallelAssembly);
        oldOnParallelAssembly = null;
        enabled = false;
    }
216171
public void setEnableListeners(boolean[] rgbEnabled)
    {
        int iIndex = 0;
        FieldListener fieldBehavior = this.getListener();
        while (fieldBehavior != null)
        {
            boolean bEnable = true;
            if ((rgbEnabled != null) && (iIndex < rgbEnabled.length))
                bEnable = rgbEnabled[iIndex];
            fieldBehavior.setEnabledListener(bEnable);
            
            fieldBehavior = (FieldListener)fieldBehavior.getNextListener();
            iIndex++;
        }
    }
1248106
protected void addToNonSingletonListeners(final Object bean) {
        if( logger.isDebugEnabled() )
            logger.debug( "Adding Authentication/LoginAware bean to list of non-singleton listeners: bean='" + bean );

        nonSingletonListeners.add( new WeakReference( bean ) );
    }
103425
def _disable(self):
        
        if self._enabled:
            self._real_onCannotSend()
            has_cancelled = 0
            for block in self._aio_recv_block_list + self._aio_send_block_list:
                try:
                    self._aio_context.cancel(block)
                except OSError as exc:
                    trace(
                        'cancelling %r raised: %s' % (block, exc),
                    )
                else:
                    has_cancelled += 1
            if has_cancelled:
                noIntr(functools.partial(self._aio_context.getEvents, min_nr=None))
            self._enabled = False
45262
def _register_event_listeners(self, cls):
        
        event.listen(cls, 'after_insert', self._new_listener)
        event.listen(cls, 'after_update', self._update_listener)
        event.listen(cls, 'after_delete', self._delete_listener)
430355
public void setReferenceRecord(Record record)
    {
        if (m_recordReference != record)
        {
            if (m_recordReference != null)
            { // Take behaviors off old references
               // You only want to disconnect the referenced record (not free it).
                if (this.getRecord() != null)
                {
                    FreeOnFreeHandler freeListener = (FreeOnFreeHandler)this.getRecord().getListener(FreeOnFreeHandler.class);
                    while (freeListener != null)
                    {
                        if (freeListener.getDependentObject() == m_recordReference)
                        {
                            freeListener.setDependentObject(null);
                            this.getRecord().removeListener(freeListener, true);
                            break;
                        }
                        freeListener = (FreeOnFreeHandler)freeListener.getListener(FreeOnFreeHandler.class);
                    }
                }

                ClearFieldReferenceOnCloseHandler listener = (ClearFieldReferenceOnCloseHandler)m_recordReference.getListener(ClearFieldReferenceOnCloseHandler.class.getName());
                while (listener != null)
                {
                    if (listener.getField() == this)
                    {
                        Record recordTemp = m_recordReference;
                        m_recordReference = null; // Cancel echo
                        recordTemp.removeListener(listener, true);
                        listener = null;    // Got it!
                    }
                    else
                        listener = (ClearFieldReferenceOnCloseHandler)listener.getListener(ClearFieldReferenceOnCloseHandler.class.getName());
                }
            }
            if (record != null)
            { // Make sure reference is cleared when record is discarded
                record.addListener(new ClearFieldReferenceOnCloseHandler(this));
            }
            m_recordReference = record;
        }
    }
812334
public function disable()
    {
        if (!$this->enabled) {
            return;
        }
        $this->enabled = false;
        if ($this->ev instanceof \Event) {
            $this->ev->del();
        } elseif ($this->ev instanceof \EventListener) {
            $this->ev->disable();
        }
    }
929757
@Override
    void stopListening() {
        if (listening) {
            try {
                Log.v(
                    DOMAIN,
                    "%s: stopListening() unregistering %s with context %s", this, receiver, context);
                context.unregisterReceiver(receiver);
            }
            catch (Exception e) {
                Log.e(
                    DOMAIN,
                    "%s: stopListening() exception unregistering %s with context %s",
                    e,
                    this,
                    receiver,
                    context);
            }
            listening = false;
        }
    }
1370536
protected void dontNotifyAnyRequestListenersInternal() {
        lockSendRequestsToService.lock();
        try {
            if (spiceService == null) {
                return;
            }
            synchronized (mapRequestToLaunchToRequestListener) {
                if (!mapRequestToLaunchToRequestListener.isEmpty()) {
                    for (final CachedSpiceRequest<?> cachedSpiceRequest : mapRequestToLaunchToRequestListener.keySet()) {
                        final Set<RequestListener<?>> setRequestListeners = mapRequestToLaunchToRequestListener.get(cachedSpiceRequest);
                        if (setRequestListeners != null) {
                            Ln.d("Removing listeners of request to launch : " + cachedSpiceRequest.toString() + " : " + setRequestListeners.size());
                            spiceService.dontNotifyRequestListenersForRequest(cachedSpiceRequest, setRequestListeners);
                        }
                    }
                }
                mapRequestToLaunchToRequestListener.clear();
            }
            Ln.v("Cleared listeners of all requests to launch");

            removeListenersOfAllPendingCachedRequests();
        } catch (final InterruptedException e) {
            Ln.e(e, "Interrupted while removing listeners.");
        } finally {
            lockSendRequestsToService.unlock();
        }
    }
893500
def stop_listener(self):
        ''''''
        if self.sock is not None:
            self.sock.close()
            self.sock = None
        self.tracks = {}