Retrieve the property display type.

@return string
435209
public function displayType()
    {
        if ($this->displayType === null) {
            $this->displayType = $this->resolveDisplayType();
        }

        return $this->displayType;
    }
306535
public function getDisplayValue()
    {
        $result = '';
        $datetime = $this->getDateTime();
        if ($datetime !== null) {
            if ($this->akDateDisplayMode === null) {
                $this->load();
            }
            $dh = $this->app->make('helper/date');
            /* @var \Concrete\Core\Localization\Service\Date $dh */
            switch ($this->akDateDisplayMode) {
                case 'date':
                    $result = $dh->formatDate($datetime, 'short', $datetime->getTimezone());
                    break;
                case 'date_text':
                    if ($this->akTextCustomFormat === '') {
                        $result = $dh->formatDate($datetime, 'short', $datetime->getTimezone());
                    } else {
                        $result = $dh->formatCustom($this->akTextCustomFormat, $datetime, $datetime->getTimezone());
                    }
                    break;
                case 'text':
                    if ($this->akTextCustomFormat === '') {
                        $result = $dh->formatDateTime($datetime);
                    } else {
                        $result = $dh->formatCustom($this->akTextCustomFormat, $datetime);
                    }
                    break;
                case 'date_time':
                default:
                    $result = $dh->formatDateTime($datetime);
                    break;
            }
        }

        return $result;
    }
598694
public function getInputType()
    {
        switch ($this->type) {
            case self::NUMBER_TYPE: return 'number';
            case self::DATE_TYPE: return 'date';
            case self::STRING_TYPE: return 'string';
            case self::COUNTRY_TYPE: return 'country';
            case self::EMAIL_TYPE: return 'email';
            case self::HTML_TYPE: return 'html';
            case self::CASCADE_TYPE: return 'cascade_select';
            case self::FILE_TYPE: return 'file';
            case self::BOOLEAN_TYPE: return 'boolean';
            case self::CHOICE_TYPE: return 'choice';
            default: return 'error';
        }
    }
355261
function classDisplayInfo()
    {
        $classAttribute = $this->contentClassAttribute();
        if ( !$classAttribute->DisplayInfo )
        {
            $dataType = $this->dataType();
            if ( $dataType )
            {
                $classAttribute->DisplayInfo = $dataType->classDisplayInformation( $classAttribute, false );
            }
        }
        return $classAttribute->DisplayInfo;
    }
910529
public function getType(): string
    {
        if (null === $this->type) {
            $success = true;

            $type = $this->getItem('browscap.type', false, $success);

            if (null !== $type && $success) {
                $this->type = $type;
            }
        }

        return $this->type;
    }
935550
public function outputType()
    {
        if ($this->outputType === null) {
            if ($this->inputType === false && $this->displayType === false) {
                throw new LogicException('Form property widget requires an "input_type" or a "display_type"');
            }

            $type = null;

            if ($this->inputType === false || is_string($this->displayType)) {
                $type = static::PROPERTY_DISPLAY;
            }

            if ($this->displayType === false || is_string($this->inputType)) {
                $type = static::PROPERTY_CONTROL;
            }

            $this->outputType = $type;
        }

        return $this->outputType;
    }
1118035
public function getMediaType() : ?string 
    {
        if ( ! $this->hasMediaType()) {
            $this->setMediaType($this->getDefaultMediaType());
        }
        return $this->mediaType;
    }
178323
public function get_css_type() {
        if (array_key_exists($this->type, $this->namedtypes)) {
            return 'type_'.$this->namedtypes[$this->type];
        }
        return 'type_unknown';
    }
854990
public function displayTypeProperty(Request $request)
    {
        if (!$request->isXmlHttpRequest()) {
            $this->app->abort(400);
        }

        $records = RecordsRequest::fromRequest($this->app, $request, false, [\ACL::CANMODIFRECORD]);

        $recordsType = [];

        foreach ($records as $record) {
            //perform logic
            $sbasId = $record->getDataboxId();

            if (!isset($recordsType[$sbasId])) {
                $recordsType[$sbasId] = [];
            }

            if (!isset($recordsType[$sbasId][$record->getType()])) {
                $recordsType[$sbasId][$record->getType()] = [];
            }

            $recordsType[$sbasId][$record->getType()][] = $record;
        }

        return new Response($this->render('prod/actions/Property/type.html.twig', [
            'records'     => $records,
            'recordsType' => $recordsType,
        ]));
    }
439331
public static function convertToDisplayType(\ReflectionType $type)
    {
        static $typeMap = [
            'int'  => 'integer',
            'bool' => 'boolean'
        ];
        $displayType = (string)$type;
        if (isset($typeMap[$displayType])) {
            $displayType = $typeMap[$displayType];
        }

        $displayType = ltrim($displayType, '\\');

        if ($type->allowsNull()) {
            $displayType .= ' or NULL';
        }

        return $displayType;
    }
449887
protected function getDisplayAsColumns()
    {
        $display = $this->getVariable('display');

        // tabs
        if (null == $display || 0 == sizeof($display)) {
            $tabs = $this->getVariable('tabs');

            if (null != $tabs || 0 < sizeof($tabs)) {
                $display = array();

                foreach ($tabs as $tab) {
                    $display = array_merge($display, $tab);
                }
            }
        }

        if (null == $display || 0 == sizeof($display)) {
            return $this->getAllFields();
        }

        if (isset($display[0])) {
            return $display;
        }

        //there is fieldsets
        $return = array();

        foreach ($display as $fieldset => $rows_or_fields) {
            foreach ($rows_or_fields as $fields) {
                if (is_array($fields)) { //It s a row
                    $return = array_merge($return, $fields);
                } else {
                    $return[$fields] = $fields;
                }
            }
        }

        return $return;
    }
1216067
public function getFormStyle()
    {
        $prop = array();

        $prop['alignment'] = $this->value['text-align'];

        if (isset($this->value['background']['color']) && is_array($this->value['background']['color'])) {
            $prop['fillColor'] = $this->value['background']['color'];
        }

        if (isset($this->value['border']['t']['color'])) {
            $prop['strokeColor'] = $this->value['border']['t']['color'];
        }

        if (isset($this->value['border']['t']['width'])) {
            $prop['lineWidth'] = $this->value['border']['t']['width'];
        }

        if (isset($this->value['border']['t']['type'])) {
            $prop['borderStyle'] = $this->value['border']['t']['type'];
        }

        if (!empty($this->value['color'])) {
            $prop['textColor'] = $this->value['color'];
        }

        if (!empty($this->value['font-size'])) {
            $prop['textSize'] = $this->value['font-size'];
        }

        return $prop;
    }
985448
protected function getLayoutType() {
        $detector = new MobileDetect();
        $isMobile = $detector->isMobile();
        $isTablet = $detector->isTablet();
        unset($detector);

        return array('isMobile' => $isMobile, 'isTablet' => $isTablet, 'isDesktop' => (!$isMobile && !$isTablet));
    }
467640
public function getModelDisplayName()
    {
        $instance = $this->getModelInstance();
        $display = isset($instance->display) ? $instance->display : ucfirst($this->model);

        return $display;
    }
1120083
public function getType() : ?string
    {
        if (null === $this->type) {
            $success = null;

            try {
                $type = $this->getItem('browscap.type', false, $success);
            } catch (InvalidArgumentException $e) {
                $this->logger->error(new \InvalidArgumentException('an error occured while reading the data type from the cache', 0, $e));
                $type = null;
            }

            if (null !== $type && $success) {
                $this->type = $type;
            }
        }

        return $this->type;
    }
970597
function GetPhpType()
	{
		$rt = $this->Type;
		switch ($this->Type)
		{
			case "smallint":
			case "bigint":
			case "tinyint":
			case "mediumint":
				$rt = "int";
				break;
			case "varchar":
			case "text":
			case "tinytext":
				$rt = "string";
				break;
			case "date":
			case "datetime":
				$rt = "date";
				break;
			case "decimal":
			case "float":
				$rt = "float";
				break;
			default;
				break;
		}

		return $rt;
	}
174216
public function display()
    {
        $name = $this->getName();

        $data = array();

        //if data is set the just json encode those
        if (count($this->_data)) {
            $this->output = $this->_data;
        } elseif (AnInflector::isPlural($name)) {
            $this->output = $this->_getList();
        } else {
            $this->output = $this->_getItem();
        }

        //if null then return empty string
        $this->output = pick($this->output, '');

        if (!is_string($this->output)) {
            $this->output = json_encode($this->_toArray(AnConfig::unbox($this->output)));
        }

        //Handle JSONP
        if (! empty($this->_padding)) {
            $this->output = $this->_padding.'('.$this->output.');';
        }

        return $this->output;
    }