Returns the full content dimensions presets as JSON object; see
ContentDimensionPresetSourceInterface::getAllPresets() for a format description.

@return void
548405
public function indexAction()
    {
        if ($this->view instanceof JsonView) {
            $this->view->assign('value', $this->contentDimensionPresetSource->getAllPresets());
        } else {
            $this->view->assign('contentDimensionsPresets', $this->contentDimensionPresetSource->getAllPresets());
        }
    }
49007
protected function getInsertDimensions()
    {
        $width = $this->owner->getWidth();
        $height = $this->owner->getHeight();
        if (!$height || !$width) {
            return null;
        }

        $maxWidth = $this->owner->config()->get('insert_width');
        $maxHeight = $this->owner->config()->get('insert_height');

        // Within bounds
        if ($width < $maxWidth && $height < $maxHeight) {
            return [
                'width' => $width,
                'height' => $height,
            ];
        }

        // Check if sizing by height or width
        if (($width * $maxHeight) < ($height * $maxWidth)) {
            // Size by height
            return [
                'width' => intval(($width * $maxHeight) / $height + 0.5),
                'height' => $maxHeight,
            ];
        } else {
            // Size by width
            return [
                'width' => $maxWidth,
                'height' => intval(($height * $maxWidth) / $width + 0.5),
            ];
        }
    }
394046
private function getColumns()
    {
        $dimensions = $this->getApplication()->getTerminalDimensions();
        if (is_array($dimensions) && count($dimensions) > self::DIMENSION_WIDTH) {
            return $dimensions[self::DIMENSION_WIDTH];
        } else {
            return self::DEFAULT_WIDTH;
        }
    }
371503
public function getAllItems() {
    if (version_compare(phpversion(), '5.3.0', '<')) {
      return json_encode($this->m_aItems);
    }
    else {
      return json_encode($this->m_aItems, JSON_UNESCAPED_UNICODE);
    }
  }
246838
public function getContentExtensions()
    {
        $extensions = [];
        foreach ($this->types as $type) {
            $extensions = array_merge($extensions, $type->getExtensions());
        }

        return array_unique($extensions);
    }
205629
public function getFullDataSet () : array
    {
        if ($this->isUsingHandler()) :
            $this->regularize();
            $this->clearCache();

            return $this->_Cache = $this->_DataHandler->selectRangeEntitys(0,$this->_maxKey + 1);
        else :
            return $this->_Container;
        endif;
    }
115225
private function getAllSetData()
    {
        $data = [];
        foreach (get_object_vars($this) as $key => $value) {
            if ($value) {
                $data[$key] = $value;
            }
        }

        return $data;
    }
1118245
private function getAllSetData()
    {
        $data = [];
        foreach ($this->customFields as $customField) {
            $data[$customField->getName()] = $customField->getValue();
        }

        return $data;
    }
763882
protected function renderContentSets()
    {
        $ret = '';
        $ret .= $this->start('table');
        $ret .= $this->element('caption', 'Content Sets');
        foreach ($this->def->info_content_sets as $name => $lookup) {
            $ret .= $this->heavyHeader($name);
            $ret .= $this->start('tr');
            $ret .= $this->element('td', $this->listifyTagLookup($lookup));
            $ret .= $this->end('tr');
        }
        $ret .= $this->end('table');
        return $ret;
    }
1028601
public function getData()
    {
        try {
            $this->parse();
            $organized_statements = array();
            foreach ($this->dependencies as $name=>$preset) {
                foreach ($preset->getStatements() as $type=>$statements) {
                    if (!isset($organized_statements[$type])) {
                        $organized_statements[$type] = array();
                    }
                    foreach ($statements as $statement) {
                        $organized_statements[$type][] = $statement;
                    }
                }
            }
            foreach ($organized_statements as $type=>$stacks) {
                $organized_statements[$type] = $preset->getOrderedStatements($stacks);
            }
        } catch (\Exception $e) {
            throw $e;
        }
        return $organized_statements;
    }
152736
protected function getAllSettingsFlat()
    {
        return $this->getAllSettings()->flatMap(function (Model $model) {
            return [$model->key => json_decode($model->value)[0]];
        });
    }
1360243
public function deletePreset() {
		$key = esc_html($_POST['key']);
		if(empty($key)) {
			json_response([
				              'status' => 'error',
				              'error' => 'Seems that you may have forgotten something.'
			              ]);
		}


		$presets = get_option('ilab-imgix-presets');
		if($presets) {
			unset($presets[$key]);
			update_option('ilab-imgix-presets', $presets);
		}

		$sizePresets = get_option('ilab-imgix-size-presets');
		if(!$sizePresets) {
			$sizePresets = [];
		}

		foreach($sizePresets as $size => $preset) {
			if($preset == $key) {
				unset($sizePresets[$size]);
				break;
			}
		}

		update_option('ilab-imgix-size-presets', $sizePresets);

		return $this->displayEditUI(1);
	}
1270215
public function getAvailableFormats()
    {
        try {
            $ret    = array();
            $result = $this->getSoapClient()->GetDocumentFormats();
            if ( isset($result->GetDocumentFormatsResult->string) ) {
                $ret = $result->GetDocumentFormatsResult->string;
                $ret = array_map('strtolower' , $ret);
            }

            return $ret;
        } catch ( SoapException $ex ) {
            throw new StatusException('Error while getting the list of available document formats' , $ex);
        }
    }
269959
public function allPreserveCase()
    {
        $fields = $this->all();
        $raw = [];
        foreach ($fields as $key => $field) {
            $raw[static::toPreserveCase($key)] = $field;
        }
        return $raw;
    }
373632
private function fetchContentAttributes()
    {
        $returnAttributeArray = array();

        $identifierArray = $this->getIdentifiers( $this->origNamePattern );

        $attributes = $this->contentObject->fetchAttributesByIdentifier( $identifierArray, $this->version, array( $this->translation ) );

        if ( is_array( $attributes ) )
        {
            foreach ( $attributes as $attribute )
            {
                $identifier = $attribute->contentClassAttributeIdentifier();
                $returnAttributeArray[$identifier] = $attribute->title();
            }
        }
        else
        {
            $returnAttributeArray = array();
        }
        $this->attributeArray = $returnAttributeArray;
    }
4423
public function getDimensions(): array
    {
        if ($this->dimensions === null) {
            $this->dimensions = getimagesize($this->file->getPathname());
        }

        return $this->dimensions;
    }
1105609
public function getFullOutput()
    {
        return array(
            LiteralField::create('HeaderMetadata', '<pre class="bold">$Metadata()</pre>'),
            LiteralField::create('LiteralMetadata', '<pre>' . nl2br(htmlentities(trim($this->owner->Metadata()), ENT_QUOTES)) . '</pre>')
        );
    }