Triggered when the renderable is removed from it's parent

@return void
491794
public function onRemoveFromParentRenderable()
    {
        try {
            $rootForm = $this->getRootForm();
            $rootForm->unregisterRenderable($this);
        } catch (FormDefinitionConsistencyException $exception) {
        }
        $this->parentRenderable = null;
    }
438945
private function renderRemoveButton()
    {
        $options = [
            'class' => 'multiple-input-list__btn js-input-remove',
        ];
        Html::addCssClass($options, $this->removeButtonOptions['class']);

        return Html::tag('div', $this->removeButtonOptions['label'], $options);
    }
1059478
public function onDeleted()
    {
        // Get the directory of an output
        if (($sources = (array) $this->outputs)      // Convert sources to an array
            && count($sources)                         // If there are sources
            && ($first = array_pop($sources))          // Get the last source
            && preg_match('#^/(?!/)#', $first)         // Make sure it's a local path
            && ($dir = public_path().dirname($first))  // Get the path of the filename
            && is_dir($dir)) {                         // Make sure it's a directory
            File::deleteDir($dir);
        }
    }
834059
public function delete()
    {
        if ( ! is_null($this->parent)) {
            $this->parent->removeChild($this->id);
        }

        $this->parent = null;
    }
452876
public function registerInFormIfPossible()
    {
        parent::registerInFormIfPossible();
        foreach ($this->renderables as $renderable) {
            if ($renderable instanceof AbstractRenderable) {
                $renderable->registerInFormIfPossible();
            }
        }
    }
976294
public function render()
    {
        if (!$this->visible) {
            return;
        }

        parent::render();

        if ($this->value === null && $this->null_display_value !== null) {
            $this->renderNullValue();
        } else {
            echo $this->getDisplayValue();
        }
    }
1047027
function() {
      var wasAttached;
      if (this.isAttachedToParent()) {
         wasAttached = this.isAttached();
        // Detach view from DOM
        this.trigger('before-dom-detach');
        if (this.injectionSite) {
          this.$el.replaceWith(this.injectionSite);
          this.injectionSite = undefined;
        } else {
          this.$el.detach();
        }
        if (wasAttached) {
          this.__invokeDetached();
        }
        this.undelegateEvents();
        this.__isAttachedToParent = false;
      }
    }
79186
protected function handleMediableDeletion()
    {
        // only cascade soft deletes when configured
        if (static::hasGlobalScope(SoftDeletingScope::class) && ! $this->forceDeleting) {
            if (config('mediable.detach_on_soft_delete')) {
                $this->media()->detach();
            }
            // always cascade for hard deletes
        } else {
            $this->media()->detach();
        }
    }
906504
public function onAfterDelete()
    {
        // Prepare blank manipulation
        $manipulations = new AssetManipulationList();

        // Add all assets for deletion
        $this->addAssetsFromRecord($manipulations, $this->owner, AssetManipulationList::STATE_DELETED);

        // Whitelist assets that exist in other stages
        $this->addAssetsFromOtherStages($manipulations);

        // Apply visibility rules based on the final manipulation
        $this->processManipulation($manipulations);
    }
1171716
@Override
	protected final void onRender()
	{
		Iterator<? extends Component> it = renderIterator();
		while (it.hasNext())
		{
			Component child = it.next();
			if (child == null)
			{
				throw new IllegalStateException(
					"The render iterator returned null for a child. Container: " + this.toString() +
						"; Iterator=" + it.toString());
			}
			renderChild(child);
		}
	}
422458
protected function renderIndestructibleReview()
    {
        if ($this->encoding && $this->encoding->status == 'complete') {
            return $this->renderPlayerOrStatus();
        }

        return $this->renderPlayerOrStatus().parent::renderIndestructibleReview();
    }
1373490
public function render()
    {
        if (!$this->visible) {
            return;
        }

        SwatCellRenderer::render();

        if ($this->value === null && $this->null_display_value !== null) {
            $this->renderNullValue();
        } else {
            $old_value = $this->value;
            $this->value = $this->value * 100;
            printf('%s%%', $this->getDisplayValue());
            $this->value = $old_value;
        }
    }
351962
protected function onBeforeDelete()
    {
        if ($this->Values()) {
            foreach ($this->Values() as $value) {
                $value->delete();
            }
        }

        parent::onBeforeDelete();
    }
588394
function(){

            var self = this;
            self.pause();

            // notify before
            this.emit('destroy');

            // remove all listeners
            self.off( true );
            // remove everything
            self.remove( self.getBodies() );
            self.remove( self.getBehaviors() );
            self.integrator( null );
            self.renderer( null );
        }
1315818
public function reset() {
		$this->defaultRenderer = new \n2n\log4php\renderer\RendererDefault();
		$this->clear();
		$this->addRenderer('Exception', '\n2n\log4php\renderer\RendererException');
	}
696168
public function afterDelete()
    {
        if ($this->cover)
        {
            /** @var Gallery_Entity_Table_Image $table  */
            $table = $this->getTable();
            $table->autoSetCover($this->section);
        }
    }
241708
public function onBeforeWrite()
    {
        // Prepare blank manipulation
        $manipulations = new AssetManipulationList();

        // Mark overwritten object as deleted
        if ($this->owner->isInDB()) {
            $priorRecord = DataObject::get(get_class($this->owner))->byID($this->owner->ID);
            if ($priorRecord) {
                $this->addAssetsFromRecord($manipulations, $priorRecord, AssetManipulationList::STATE_DELETED);
            }
        }

        // Add assets from new record with the correct visibility rules
        $state = $this->getRecordState($this->owner);
        $this->addAssetsFromRecord($manipulations, $this->owner, $state);

        // Whitelist assets that exist in other stages
        $this->addAssetsFromOtherStages($manipulations);

        // Apply visibility rules based on the final manipulation
        $this->processManipulation($manipulations);
    }