Removes the Component Widget from the engine.

        :return: Method success.
        :rtype: bool
194733
def remove_widget(self):
        

        LOGGER.debug("> Removing '{0}' Component Widget.".format(self.__class__.__name__))

        self.__preferences_manager.findChild(QGridLayout, "Others_Preferences_gridLayout").removeWidget(self)
        self.TCP_Client_Ui_groupBox.setParent(None)

        return True
141849
def clear(self):
        
        for i in range(self.count() - 1, -1, -1):
            w = self.widget(i)
            if w:
                self.removeWidget(w)
                w.close()
                w.deleteLater()
9624
def deactivate(self):
        

        raise foundations.exceptions.ProgrammingError(
            "{0} | '{1}' Component cannot be deactivated!".format(self.__class__.__name__, self.__name))
775448
def del_widget(self, ref):
        
        self.server.request("widget_del %s %s" % (self.name, ref))
        del(self.widgets[ref])
993094
def reload_components_ui(self):
        

        selected_components = self.get_selected_components()

        self.__engine.start_processing("Reloading Components ...", len(selected_components))
        reload_failed_components = []
        for component in selected_components:
            if component.interface.deactivatable:
                success = self.reload_component(component.name) or False
                if not success:
                    reload_failed_components.append(component)
            else:
                self.__engine.notifications_manager.warnify(
                    "{0} | '{1}' Component cannot be deactivated and won't be reloaded!".format(self.__class__.__name__,
                                                                                                component.name))
            self.__engine.step_processing()
        self.__engine.stop_processing()

        if not reload_failed_components:
            return True
        else:
            raise manager.exceptions.ComponentReloadError(
                "{0} | Exception(s) raised while reloading '{1}' Component(s)!".format(self.__class__.__name__,
                                                                                       ", ".join(
                                                                                           (reload_failed_component.name
                                                                                            for reload_failed_component
                                                                                            in
                                                                                            reload_failed_components))))
989866
def removeFunction(self):
        
        root = self.etree
        t_execute = root.find('execute')
        try:
            root.remove(t_execute)
            return True
        except (Exception,) as e:
            print(e)

        return False
406367
def delete(self):
        
        super(Interface, self).delete()
        for route in self._engine.routing:
            if route.to_delete:
                route.delete()
        self._engine._del_cache()
429048
def unhook_drag(self):
        
        widget = self.widget
        del widget.mousePressEvent
        del widget.mouseMoveEvent
        del widget.mouseReleaseEvent
1359764
def deactivate(self):
        

        LOGGER.debug("> Deactivating '{0}' Component.".format(self.__class__.__name__))

        self.__engine = None
        self.__settings = None
        self.__settings_section = None

        self.__script_editor = None

        self.activated = False
        return True
719845
def kill(self):
        '''
        
        '''
        Base.kill(self)
        
        for c in self.containers:
            c.remove_internal(self)
        for w in self.widgets:
            w.remove_internal(self)
1041195
def stop(self):
        
        for component in self.components:
            component.close()
            self.log('Stopping component - {}', component.__class__.__name__)

        for controller in self.controllers.values():
            controller.close()
            self.log('Stopping controller - {}', controller.__class__.__name__)

        atexit.unregister(self.stop)
386487
def reset_component(self, component):
		
		if isinstance(component, str) is True:
			component = WURI.Component(component)
		self.__components[component] = None
469312
function() {
        //remove all event handlers, delete from entities
        this.each(function() {
            var comp;
            this.trigger("Remove");
            for (var compName in this.__c) {
                comp = components[compName];
                if (comp && "remove" in comp) comp.remove.call(this, true);

                // update map from component to (entityId -> entity)
                delete compEntities[compName][this[0]];
            }
            this._unbindAll();
            delete entities[this[0]];
        });
    }
527746
def destroy(self):
        
        widget = self.widget
        if widget is not None:
            widget.removeFromSuperview()
        super(UiKitView, self).destroy()
333110
def stop(self):
        
        if not self.active:
            return
        self.removeHandler(self.handlers[-1])
        self.active = False
        return
235654
def remove(self):
        
        LOGGER.debug("InjectorCachedComponent.remove")
        ret = True
        args = {'properties': {'OPERATION': 'DEL_COMPONENT_FROM_CACHE',
                               'REMOTE_COMPONENT':
                                   str(self.injector_component_2_json(properties_only=True)).replace("'", '"'),
                               'CACHE_ID': InjectorCachedComponentService.cache_id}}

        result = InjectorCachedComponentService.requester.call(args).get()
        if result.rc != 0:
            err_msg = 'InjectorCachedComponent.remove - Problem while saving component ( id : ' + self.id + \
                      'Reason: ' + str(result.response_content) + '-' + str(result.error_message) + \
                      " (" + str(result.rc) + ")"
            LOGGER.warning(err_msg)
            ret = False

        if self.service is not None and self.service.is_started:
            self.service.stop()

        if self.actor_ref is not None:
            self.stop()

        return ret
1289597
def remove_widget(self, widget):
        

        self._grid_widgets = dict((key, val)
                                  for (key, val) in self._grid_widgets.items()
                                  if val[-1] != widget)

        self._need_solver_recreate = True