Remove respective core element of handed transition model

        :param TransitionModel model: Transition model which core element should be removed
        :return:
3681
def remove_core_element(self, model):
        
        assert model.transition.parent is self.model.state or model.transition.parent is self.model.parent.state
        gui_helper_state_machine.delete_core_element_of_model(model)
670358
def delete(self, name):
        
        if name not in self._parent:
            raise KeyError('model "{}" not present'.format(name))
        del self._parent[name]
        if self._current_model_group == name:
            self._current_model_group = None
548806
def state_machine_destruction(self, model, prop_name, info):
        
        if self.model is model:  # only used for the state machine destruction case
            self.canvas.get_view_for_model(self.root_state_m).remove()
817202
def remove_graphic(self, graphic: Graphics.Graphic, *, safe: bool=False) -> typing.Optional[typing.Sequence]:
        """"""
        return self.remove_model_item(self, "graphics", graphic, safe=safe)
1291122
public void unregisterBall(final BallModel ballModel) {
        this.ballMap.remove(ballModel.getEventModel().target());
        view().getPanel().getChildren().remove(ballModel.node());
    }
400090
def remove(self, models):
        
        models = self._check_model_types(models)
        for model in models:
            if model in self._selected:
                self._selected.remove(model)
487833
def model_changed(self, model, prop_name, info):
        

        # TODO: find nice solution
        # this in only required if the GUI is terminated via Ctrl+C signal
        if not self.view:
            # this means that the main window is currently under destruction
            return

        execution_engine = rafcon.core.singleton.state_machine_execution_engine
        label_string = str(execution_engine.status.execution_mode)
        label_string = label_string.replace("STATE_MACHINE_EXECUTION_STATUS.", "")
        self.view['execution_status_label'].set_text(label_string)

        current_execution_mode = execution_engine.status.execution_mode
        if current_execution_mode is StateMachineExecutionStatus.STARTED:
            self.view['step_buttons'].hide()
            self._set_single_button_active('button_start_shortcut')
        elif current_execution_mode is StateMachineExecutionStatus.PAUSED:
            self.view['step_buttons'].hide()
            self._set_single_button_active('button_pause_shortcut')
        elif execution_engine.finished_or_stopped():
            self.view['step_buttons'].hide()
            self._set_single_button_active('button_stop_shortcut')
        else:  # all step modes
            self.view['step_buttons'].show()
            self._set_single_button_active('button_step_mode_shortcut')
469622
function (model) {
        var newModels = slice.call(this.models);
        var modelIndex = newModels.indexOf(model);
        if (modelIndex > -1) {
            newModels.splice(modelIndex, 1);
            this.models = newModels;
            this._removeIndex(this._indexes, model);
            return true;
        }
        return false;
    }
1152648
def _get_future_expected_model(self, core_element):
        """"""
        for model in self.expected_future_models:
            if model.core_element is core_element:
                # print("expected_future_model found -> remove model:", model, [model], id(model))
                self.expected_future_models.remove(model)
                return model
        return None
473148
function(model, options) {
            var index;

            if (_.isArray(model)) {
                _.each(model, function(m) {
                    this.remove(m, options);
                }, this);
                return this;
            }

            options = _.defaults(options || {}, {
                silent: false
            });

            model = this._prepareModel(model);

            _.each(this.models, function(m, i) {
                if (!m || model.id == m.id) {
                    this.models.splice(i, 1);
                    index = i;
                    return;
                }
            }, this);
            delete this._byId[model.id];

            if (options.silent) return this;
            options.index = index;
            if (this._totalCount != null) this._totalCount = _.max([0, this._totalCount - 1]);
            this.trigger('remove', model, this, options);
            this._removeReference(model);

            return this;
        }
1240908
function( model ) {
			model.unbind( 'destroy', this.unregister );
			var coll = this.getCollection( model );
			coll && coll.remove( model );
		}
1240434
def delete(self, moveIssuesTo=None):
        
        params = {}
        if moveIssuesTo is not None:
            params['moveIssuesTo'] = moveIssuesTo

        super(Component, self).delete(params)
728115
public void setSceneModel (MisoSceneModel model)
    {
        _model = model;

        // clear out old blocks and objects
        clearScene();

        centerOnTile(0, 0);
        if (isShowing()) {
            rethink();
            _remgr.invalidateRegion(_vbounds);
        }
    }
505759
def remove_core_element(self, model):
        
        assert model.scoped_variable.parent is self.model.state
        gui_helper_state_machine.delete_core_element_of_model(model)
1291884
def unregister(self, model_or_iterable):
        
        if isinstance(model_or_iterable, ModelBase):
            model_or_iterable = [model_or_iterable]
        for model in model_or_iterable:
            if model not in self._registry:
                raise NotModerated("The model '%s' is not currently being moderated" % model._meta.module_name)
            del self._registry[model]
1257981
protected boolean deleteModel(MODEL_ID id, boolean permanent) throws Exception {
        if (permanent) {
            server.deletePermanent(modelType, id);
        } else {
            server.delete(modelType, id);
        }
        return permanent;
    }
1051760
private void performClearOperation(ModelElementInstanceImpl modelElement, Collection<DomElement> elementsToRemove) {
    Collection<ModelElementInstance> modelElements = ModelUtil.getModelElementCollection(elementsToRemove, modelElement.getModelInstance());
    for (ModelElementInstance element : modelElements) {
      modelElement.removeChildElement(element);
    }
  }