Loads the themed CSS with the given name.

@param string $name Name of themed CSS file.

@return void
765912
protected function loadThemedCSS($name)
    {
        if ($this->isDevServerActive()) {
            Requirements::css($this->getDevServerURL($this->ext($name, 'css')));
        } else {
            Requirements::themedCSS($name);
        }
    }
569478
public function loadClass($name)
    {
        $name = ltrim($name, '\\');

        if ($this->getClass($name) instanceof LazyClassReflection) {
            try {
                $this->addClass($this->store->readClass($this, $name));
            } catch (\InvalidArgumentException $e) {
                // probably a PHP built-in class
                return;
            }
        }

        return $this->classes[$name];
    }
1338670
public function setName(string $name) : void
    {
        $data = (object)[
            'threadNameDetail' => (object)[
                'threadName' => $name
            ]
        ];

        $this->putJson(sprintf(self::MESSAGE_THREAD_ENDPOINT . 'threads/%s/name', $this->messageThreadId), $data);
    }
1102486
protected function load($name)
    {
        if (!$this->initialized) {
            $this->initialize();
        }

        if (isset($this->cache[$name])) {
            return $this->cache[$name];
        }

        $cache = $this->cachePath ? sprintf('%s/%s.cache', $this->cachePath, sha1($name)) : false;

        if (!$cache) {

            $storage = new StringStorage($this->compile($this->loader->getSource($name), $name));

        } else {

            if (!is_file($cache) || !$this->isTemplateFresh($name, filemtime($cache))) {
                $this->writeCacheFile($cache, $this->compile($this->loader->getSource($name), $name));
            }

            $storage = new FileStorage($cache);
        }

        return $this->cache[$name] = $storage;
    }
1231268
protected function loadFile($name)
    {
        $fileName = $this->getFileName($name);

        if (!file_exists($fileName)) {
            throw new Mustache_Exception_UnknownTemplateException($name);
        }

        return new Mustache_Source_FilesystemSource($fileName, $this->statProps);
    }
1018840
protected function loadCss($file, array $properties = [])
    {
        if (!isset($this->loaded_css[$file])) {
            $this->loaded_css[$file] = true;

            $properties = array_merge($properties, [
                'rel' => 'stylesheet',
                'type' => 'text/css',
                'href' => $file,
            ]);

            echo $this->buildElement('link', $properties);
        }
    }
987862
public function configure($name)
    {
        if (isset($this->loadedConfigurations[$name])) {
            return;
        }
        //标记为已加载
        $this->loadedConfigurations[$name] = true;
        $path = $this->getConfigurationPath($name);
        if ($path) {
            $this->make('config')->set($name, require $path);
        }
    }
1125084
protected function loadComponent($bindings, $name)
    {
        $aliases = array_values($bindings);
        $abstracts = array_keys($bindings);
        
        foreach ($abstracts as $index => $abstract) {
            $this->app->singleton(
                $abstract,
                $this->{"load{$name}Component"}()
            );
            
            $this->app->alias(
                $abstract,
                $aliases[$index]
            );
        }
    }
274683
public function load($name)
    {
        if (!self::tableExists($name)) {
            throw new SystemException(sprintf('The table with name %s doesn\'t exist', $name));
        }

        $schema = self::getSchemaManager()->createSchema();

        $this->name = $name;
        $this->tableInfo = $schema->getTable($this->name);
        $this->loadColumnsFromTableInfo();
        $this->exists = true;
    }
2162
public function setImagePrettyName($name)
    {
        $this->set('prettyname', $name);
        if ($this->image) {
            $this->image->setPrettyName($name);
        }
    }
41231
public function style($name)
    {
        if ($this->hasStyle($name)) {
            $this->setPresenter($this->getStyle($name));
        }

        return $this;
    }
1232660
public function setLabel( $name )
	{
		if ( $name == $this->getLabel() ) { return; }

		$this->_values['label'] = (string) $name;
		$this->setModified();
	}
392051
public static function getStyleDefinition($name)
    {
        if (!self::$styles) {
            self::$styles = self::initStyles();
        }

        if (isset(self::$styles[$name])) {
            return self::$styles[$name];
        }

        throw new InvalidArgumentException(sprintf('Style "%s" is not defined.', $name));
    }
1213750
protected function configure($name)
    {
        $path = $this->app->basePath("config/{$name}.php");

        if (!is_readable($path)) {
            $path = dirname(__DIR__) . "/config/{$name}.php";
        }

        $this->app->make('config')->set($name, require $path);
    }
81056
public static function getCss($name = 'css')
    {
        $output = Load::CSS($GLOBALS[self::$pref.$name]);

        return $output;
    }
781929
public function addFlag(string $name): void
    {
        if (!$this->hasFlag($name)) {
            $flagEntry = $this->entry[PoTokens::FLAG];
            if ($flagEntry === null) {
                $this->set(PoTokens::FLAG, $name);
            } elseif (is_array($flagEntry)) {
                $flagEntry[] = $name;
                $this->set(PoTokens::FLAG, implode(',', $flagEntry));
            } else {
                $this->set(PoTokens::FLAG, $flagEntry . ',' . $name);
            }
        }
    }
1020384
protected function loadCache(string $name)
    {
        $path = $this->cache_path;
        $cache_file = $path . '/' . $name  . '.cache';

        if (file_exists($cache_file))
        {
            if (!is_readable($cache_file))
            {
                self::getLogger()->error("Cannot read cache from {0}", [$cache_file]);
            }
            else
            {
                try
                {
                    $contents = file_get_contents($cache_file);
                    $data = unserialize($contents);
                    if (!is_array($data))
                        $data = [];
                    $this->repository[$name] = $data;
                    $this->repository[$name]['_changed'] = false;
                    $this->checkExpiry($name);
                    return;
                }
                catch (\Throwable $t)
                {
                    self::getLogger()->error("Failure loading cache {0} - removing", [$name]);
                    self::getLogger()->error("Error: {0}", [$t]);
                    if (is_writable($cache_file))
                        unlink($cache_file);
                }
            }
        }
        self::getLogger()->debug("Cache {0} does not exist - creating", [$cache_file]);
        $this->repository[$name] = [];
    }