Get allowed styles

@return string[]
490035
public static function getKnownStyles()
    {
        $styles = array(
            static::BOLD      => static::BASH_BOLD,
            static::UNDERLINE => static::BASH_UNDERLINE,
            static::BLINK     => static::BASH_BLINK,
            static::INVISIBLE => static::BASH_INVISIBLE,
        );

        return $styles;
    }
891907
public function allowedHttpVerbs() : array
    {
        return [
            HttpRequest::METHOD_GET,
            HttpRequest::METHOD_POST,
            HttpRequest::METHOD_PATCH,
            HttpRequest::METHOD_DELETE,
            HttpRequest::METHOD_HEAD,
            HttpRequest::METHOD_OPTIONS,
        ];
    }
1226657
public function getThemeCustomizableStylePresets()
    {
        $presets = [];
        $env = Environment::get();
        if ($this->isThemeCustomizable()) {
            $directory = $env->getPath(
                DIRNAME_THEMES.'/'.$this->getThemeHandle(
                ).'/'.DIRNAME_CSS.'/'.DIRNAME_STYLE_CUSTOMIZER_PRESETS,
                $this->getPackageHandle()
            );
            $urlroot = $env->getURL(
                DIRNAME_THEMES.'/'.$this->getThemeHandle().'/'.DIRNAME_CSS,
                $this->getPackageHandle()
            );
            $dh = Loader::helper('file');
            $files = $dh->getDirectoryContents($directory);
            foreach ($files as $f) {
                if (strrchr($f, '.') == static::THEME_CUSTOMIZABLE_STYLESHEET_EXTENSION) {
                    $preset = Preset::getFromFile($directory.'/'.$f, $urlroot);
                    if (is_object($preset)) {
                        $presets[] = $preset;
                    }
                }
            }
        }
        usort(
            $presets,
            function ($a, $b) {
                if ($a->isDefaultPreset()) {
                    return -1;
                } else {
                    return strcasecmp($a->getPresetDisplayName('text'), $b->getPresetDisplayName('text'));
                }
            }
        );

        return $presets;
    }
872404
public function getStyles()
    {
        $styles = $this->config()->get('styles');
        $i18nStyles = array();
        if ($styles) {
            foreach ($styles as $key => $label) {
                $i18nStyles[$key] = _t('PlaceableObject_Preset.STYLE'.strtoupper($key), $label);
            }
        }
        return $i18nStyles;
    }
290599
public function formatStylesJs()
    {
        $options = [];

        $options[] = $this->formatStyle('Arial,Arial,Helvetica,sans-serif', 'Arial');
        $options[] = $this->formatStyle('Arial Black,Arial Black,Gadget,sans-serif', 'Arial Black');
        $options[] = $this->formatStyle('Comic Sans MS,Comic Sans MS,cursive', 'Comic Sans MS');
        $options[] = $this->formatStyle('Courier New,Courier New,Courier,monospace', 'Courier New');
        $options[] = $this->formatStyle('Georgia,Georgia,serif', 'Georgia');
        $options[] = $this->formatStyle('Impact,Charcoal,sans-serif', 'Impact');
        $options[] = $this->formatStyle('Lucida Console,Monaco,monospace', 'Lucida Console');
        $options[] = $this->formatStyle('Lucida Sans Unicode,Lucida Grande,sans-serif', 'Lucida Sans');
        $options[] = $this->formatStyle('Palatino Linotype,Book Antiqua,Palatino,serif', 'Palatino Linotype');
        $options[] = $this->formatStyle('Tahoma,Geneva,sans-serif', 'Tahoma');
        $options[] = $this->formatStyle('Times New Roman,Times,serif', 'Times New Roman');
        $options[] = $this->formatStyle('Trebuchet MS,Helvetica,sans-serif', 'Trebuchet');
        $options[] = $this->formatStyle('Verdana,Geneva,sans-serif', 'Verdana');

        return 'aoTypes: ['.implode(', ', $options).']';
    }
863441
public function getStyle(string $s): array
    {
        if (!isset($this->wt_report->styles[$s])) {
            $s                           = $this->getCurrentStyle();
            $this->wt_report->styles[$s] = $s;
        }

        return $this->wt_report->styles[$s];
    }
445988
public static function getAllowedFunctions()
    {
        $properties = array(
            static::PROPERTY_DRAG,
            static::PROPERTY_DROP,
            static::PROPERTY_EDIT,
            static::PROPERTY_DELETE,
        );

        $class = get_called_class();

        if ( is_a( $class, __NAMESPACE__ . '\RepresentsTextContentInterface', true ) )
        {
            $properties[] = static::PROPERTY_REPRESENTS_TEXT;
        }

        if ( is_a( $class, __NAMESPACE__ . '\RepresentsImageContentsInterface', true ) )
        {
            $properties[] = static::PROPERTY_REPRESENTS_IMAGES;
        }

        return $properties;
    }
1181564
private function getStylesMedia()
    {
        $media = $this->getArgument('media');
        $allowed = $this->getAllowedMedia();

        if ($media) {
            if (! $this->isAllowedMedia($media)) {
                throw new AssetException('Illegal media: Style assets acceptable madia '.implode(', ', $allowed));
            }

            return $media;
        }

        return reset($allowed);
    }
803098
public function getAllowedStates()
    {
        // Get states from extending object. (ie. Page, DataObject)
        $allowedStates = $this->owner->config()->allowed_states;
        if (is_array($allowedStates) &&
            $allowedStates) {
            return $allowedStates;
        }

        // Get allowed states global. If there are no specific rules on a Page/DataObject
        // fallback to what is configured on this extension
        $allowedStates = Config::inst()->get(__CLASS__, 'allowed_states');
        if (is_array($allowedStates) &&
            $allowedStates) {
            return $allowedStates;
        }
        return [];
    }
284680
public function getAssets()
    {
        $css = $this->theme->getThemeInfoExtendAware('css');
        $js = $this->theme->getThemeInfoExtendAware('javascript');

        return [
            'css' => $css,
            'javascript' => $js,
        ];
    }
124126
public function getRequiredCSSFiles()
    {
        $files = [];
        
        foreach (ClassInfo::subclassesFor(ContentController::class) as $controller) {
            
            if ($required_css = Injector::inst()->get($controller)->getRequiredCSS()) {
                
                foreach ($required_css as $file) {
                    
                    $file = ModuleResourceLoader::singleton()->resolvePath($file);
                    
                    if (!isset($files[$file])) {
                        $files[$file] = file_get_contents(Director::getAbsFile($file));
                    }
                    
                }
                
            }
            
        }
        
        return $files;
    }
289957
public function getTypeAllowableValues()
    {
        return [
            self::TYPE_PARENTGUARDIAN,
            self::TYPE_EMERGENCY,
            self::TYPE_PRIMARY,
            self::TYPE_SECONDARY,
            self::TYPE_FAMILY,
            self::TYPE_OTHER,
            self::TYPE_EMPTY,
        ];
    }
332911
public function getStylesheets()
    {
        $parse_stylesheets = function ($params, $stylesheets) {
            foreach ($params as $css) {
                if (is_string($css)) {
                    $css = array(
                        'path' => $css,
                        'media' => 'all',
                    );
                }

                $stylesheets[] = $css;
            }

            return $stylesheets;
        };

        // From config.yml
        $stylesheets = $parse_stylesheets(
            $this->getGenerator()->getFromBundleConfig('stylesheets', array()), array()
        );

        // From generator.yml
        $stylesheets = $parse_stylesheets(
            $this->getVariable('stylesheets', array()), $stylesheets
        );

        return $stylesheets;
    }
1090209
public function getDefaultAllowedThemesOptionList()
    {
        $ret = [];
        $all = list_themes();

        foreach ($this->getDefaultAllowedThemes() as $theme) {
            if (isset($all[$theme])) {
                $ret[$theme] = $all[$theme]->info['name'];
            } else {
                $ret[$theme] = "oups";
            }
        }

        return $ret;
    }
477115
public function getDynamicStyles()
    {
        $rawDocFont = $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_DOC_FONT);
        return [
            'nameStyle' => explode(
                ',',
                $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_NAME_STYLE)
            ),
            'priceStyle' => explode(
                ',',
                $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_PRICE_STYLE)
            ),
            'linkStyle' => explode(
                ',',
                $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_LINK_STYLE)
            ),
            'otherStyle' => explode(
                ',',
                $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_OTHER_STYLE)
            ),
            'nameColor' => $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_NAME_COLOR),
            'fontSize' => $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_NAME_FONT_SIZE),
            'priceColor' => $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_PRICE_COLOR),
            'priceFontSize' => $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_PRICE_FONT_SIZE),
            'urlColor' => $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_LINK_COLOR),
            'urlFontSize' => $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_LINK_FONT_SIZE),
            'otherColor' => $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_OTHER_COLOR),
            'otherFontSize' => $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_OTHER_FONT_SIZE),
            'docFont' => $this->getSanitisedFont($rawDocFont),
            'docBackgroundColor' => $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_DOC_BG_COLOR),
            'dynamicStyling' => $this->helper->getConfigValue(Config::XML_PATH_CONNECTOR_DYNAMIC_STYLING),
        ];
    }
904715
public function getCss()
    {
        if (isset($this->_themeConfig['css'])) {
            return array_merge($this->_themeConfig['css'], $this->_data['css']);
        } else {
            return $this->_data['css'];
        }
    }
583569
protected function getAllowedPublicMethods(): array
    {
        $allowedInterfaces = \array_unique(\array_merge($this->getAllowedInterfaces(), [ImmutabilityBehaviour::class]));
        $allowedMethods = \array_merge(
            ...\array_map(
                function (string $interface): array {
                    return (new \ReflectionClass($interface))->getMethods(\ReflectionMethod::IS_PUBLIC);
                },
                $allowedInterfaces
            )
        );

        return \array_unique(\array_filter(\array_map(
            function (\ReflectionMethod $method): string {
                return !$method->isStatic() ? $method->getName() : '';
            },
            $allowedMethods
        )));
    }