DS method to deactivate this component.
Best practice: this should be a protected method, not public or private
331360
@Deactivate
    protected void deactivate(int reason) {
        final String methodName = "deactivate";
        final boolean trace = TraceComponent.isAnyTracingEnabled();
        if (trace && tc.isEntryEnabled())
            Tr.entry(tc, methodName, "Entry Count: " + ++JDBCMBeanRuntime.counterDeactivate);
        if (trace && tc.isEventEnabled())
            Tr.event(tc, className + methodName + ", reason=" + reason);
        if (trace && tc.isEntryEnabled())
            Tr.exit(tc, methodName, "Normal Exit");
    }
380718
@Deactivate
    protected void deactivate(ComponentContext cc) {

        this.cContext = null;
        jaxwsInFlowClientSideGlobalHandlers.deactivate(cContext);
        jaxwsOutFlowClientSideGlobalHandlers.deactivate(cContext);
        jaxwsInFlowServerSideGlobalHandlers.deactivate(cContext);
        jaxwsOutFlowServerSideGlobalHandlers.deactivate(cContext);

        jaxrsInFlowClientSideGlobalHandlers.deactivate(cContext);
        jaxrsOutFlowClientSideGlobalHandlers.deactivate(cContext);
        jaxrsInFlowServerSideGlobalHandlers.deactivate(cContext);
        jaxrsOutFlowServerSideGlobalHandlers.deactivate(cContext);

    }
139271
@SuppressWarnings("unchecked")
	public void deassociate(HttpServletRequest context) {
		Map<Descriptor<?>, Object> components 
				= (Map<Descriptor<?>, Object>) context.getAttribute(COMPONENTS);
		
		for (Object component : components.values()) {
			try {
				Event.of(Passivated.class).on(component).fire();
			} catch (Exception e) {}
		}
		
		context.removeAttribute(COMPONENTS);
		
		for (Object component : components.values()) {
			try {
				Event.of(Destroyed.class).on(component).fire();
			} catch (Exception e) {}
		}
	}
117141
public void deactivate ()
    {
        if (_host != null) {
            // unwire ourselves from the host component
            Component comp = _host.getComponent();
            comp.removeMouseListener(this);
            comp.removeMouseMotionListener(this);

            // reinstate the previous mouse listeners
            if (_hijacker != null) {
                _hijacker.release();
                _hijacker = null;
            }

            // tell our host that we are no longer
            _host.menuDeactivated(this);

            // fire off a last repaint to clean up after ourselves
            repaint();
        }

        // clear out our references
        _host = null;
        _tbounds = null;
        _argument = null;

        // clear out our action listeners
        _actlist.clear();
    }
794831
def __deactivate_shared_objects(self, plugin, *args, **kwargs):
        
        shared_objects = self.get()
        for shared_object in shared_objects.keys():
            self.unregister(shared_object)
1230608
final void deactivateNow() {
      isActive = false;
      stats.deactivate();
      availableQueue.clear();
      reopenExecutor.getQueue().clear();
      for(ConnectionPoolConnection conn : connections) {
         conn.forceRealClose();
         conn.state.set(ConnectionPoolConnection.STATE_DISCONNECTED);
      }
   }
725529
@Deactivate
    protected void deactivate(ComponentContext context) {
        lock.writeLock().lock();
        try {
            componentContext = null;
            properties = null;
            threadContextConfigurations = null;
        } finally {
            lock.writeLock().unlock();
        }
    }
929693
@Override
    public void deactivate() throws InterruptedException, CouldNotPerformException {
        synchronized (maintainerLock) {
            try {
                verifyMaintainability();
                validateInitialization();
            } catch (InvalidStateException ex) {
                // was never initialized!
                return;
            }
            if (connectionState != RECONNECTING) {
                skipSyncTasks();
                setConnectionState(DISCONNECTED);
                if (pingTask != null && !pingTask.isDone()) {
                    pingTask.cancel(true);
                }
            }
            if (listenerWatchDog != null) {
                listenerWatchDog.deactivate();
            }

            if (remoteServerWatchDog != null) {
                remoteServerWatchDog.deactivate();
            }
        }
        synchronized (connectionMonitor) {
            connectionMonitor.notifyAll();
        }
    }
553537
synchronized void deactivateProbe(ProbeImpl probe) {
        listenersByProbe.remove(probe);
        activeProbesById.remove(probe.getIdentifier());

        Class<?> clazz = probe.getSourceClass();
        Map<String, ProbeImpl> classProbesByKey = probesByKey.get(clazz);
        classProbesByKey.remove(probe.getName());
        if (classProbesByKey.isEmpty()) {
            probesByKey.remove(clazz);
        }
    }
35429
protected void deactivate(ComponentContext context, int reason) throws Exception {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "Deactivating, reason=" + reason);
        }

        this.registry.removeAll();
    }
309291
def deactivate(self):
        
        self.rubber_band.reset(QgsWkbTypes.PolygonGeometry)
        QgsMapTool.deactivate(self)
        self.deactivated.emit()
1016693
@SuppressWarnings("unused")
    @Deactivate
    protected void deactivate(ComponentContext context) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Deactivating the HTTP pipeline event handler");
        }
    }
1199184
void deactivate(String clientID) {
        for (Subscription s : m_subscriptions) {
            if (s.clientId.equals(clientID)) {
                s.setActive(false);
            }
        }

        //go deep
        for (TreeNode child : m_children) {
            child.deactivate(clientID);
        }
    }
763979
@Override
    void deactivate()
    {
        final String methodName = "deactivate";
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
        {
            SibTr.entry(this, TRACE, methodName);
        }

        clearTimer();

        super.deactivate();

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
        {
            SibTr.exit(this, TRACE, methodName);
        }
    }
1006731
def disable_component(self, component):
        
        if not isinstance(component, type):
            component = component.__class__
        self.enabled[component] = False
        self.components[component] = None
1331363
protected void deactivate(ComponentContext context) {
        appListener.unregister(this);

        // shut down instances that were created
        if (!clients.isEmpty())
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                @Override
                public Void run() {
                    Method shutdown = null;
                    for (Object client : clients.values())
                        try {
                            if (shutdown == null)
                                shutdown = client.getClass().getMethod("shutdown");
                            shutdown.invoke(client);
                        } catch (Throwable x) {
                            // FFDC will be logged, otherwise ignore
                        }
                    return null;
                }
            });

        containerAuthDataRef.deactivate(context);
        sslConfig.deactivate(context);
    }
1182894
function() {
        var deactivated = false;
        if(this.map) {
            if(OpenLayers.Control.prototype.deactivate.apply(this)) {
                for(var type in this.listeners) {
                    this.map.events.unregister(
                        type, this, this.listeners[type]
                    );
                }
                if(this.clearOnDeactivate) {
                    this.clear();
                }
                deactivated = true;
            }
        }
        return deactivated;
    }