Load the view component

@param bool $try
@return void
9461
private function loadView(bool $try = false) : void
  {
    // configure view component
    Accessor::$viewsExtension = config('view.extension');
    Accessor::$viewsEngine    = config('view.engine');
    Accessor::$viewsCache     = config('app.dir') . config('view.compiled');
    Accessor::$viewsDirectory = config('app.dir') . config('view.views');

    // load component
    Accessor::requireView();
  }
27772
public function load() {
		session_start();

		$this->loadSiteClass();
		$this->checkRedirect();
		$this->applyViewRenderer();

		$this->loadController();
		$this->render();

	}
582291
public function load() {

		do_action( 'pods_components_load' );

		foreach ( (array) $this->components as $component => $component_data ) {
			$component_id = $component_data['ID'];

			$component_data['MustUse'] = apply_filters( "pods_component_require_{$component_id}", $component_data['MustUse'], $component_data );

			if ( false === $component_data['MustUse'] && ( ! isset( $this->settings['components'][ $component ] ) || 0 === $this->settings['components'][ $component ] ) ) {
				continue;
			}

			if ( ! empty( $component_data['PluginDependency'] ) ) {
				$dependency = explode( '|', $component_data['PluginDependency'] );

				if ( ! pods_is_plugin_active( $dependency[1] ) ) {
					continue;
				}
			}

			if ( ! empty( $component_data['ThemeDependency'] ) ) {
				$dependency = explode( '|', $component_data['ThemeDependency'] );

				$check = strtolower( $dependency[1] );

				if ( strtolower( get_template() ) !== $check && strtolower( get_stylesheet() ) !== $check ) {
					continue;
				}
			}

			if ( false === $component_data['External'] ) {
				$component_data['File'] = realpath( $this->components_dir . $component_data['File'] );
			}

			if ( empty( $component_data['File'] ) ) {
				pods_transient_clear( 'pods_components' );

				continue;
			}

			if ( ! file_exists( $component_data['File'] ) ) {
				pods_message( 'Pods Component not found: ' . $component_data['File'] );

				pods_transient_clear( 'pods_components' );

				continue;
			}

			include_once $component_data['File'];

			if ( ( ! empty( $component_data['Class'] ) && class_exists( $component_data['Class'] ) ) || isset( $component_data['object'] ) ) {
				if ( ! isset( $this->components[ $component ]['object'] ) ) {
					$this->components[ $component ]['object'] = new $component_data['Class']();
				}

				if ( method_exists( $this->components[ $component ]['object'], 'options' ) ) {
					if ( isset( $this->settings['components'][ $component ] ) ) {
						$this->components[ $component ]['options'] = $this->components[ $component ]['object']->options( $this->settings['components'][ $component ] );
					} else {
						$this->components[ $component ]['options'] = $this->components[ $component ]['object']->options( array() );
					}

					$this->options( $component, $this->components[ $component ]['options'] );
				} else {
					$this->options( $component, array() );
				}

				if ( method_exists( $this->components[ $component ]['object'], 'handler' ) ) {
					$this->components[ $component ]['object']->handler( $this->settings['components'][ $component ] );
				}
			}//end if
		}//end foreach
	}
521118
public function loadView( ezcMvcRoutingInformation $routeInfo, ezcMvcRequest $request, ezcMvcResult $result )
    {
        if ( $routeInfo->controllerClass === 'ezpRestAtomController' )
        {
            return new ezpRestAtomView( $request, $result );
        }
        return new ezpRestJsonView( $request, $result );
    }
197159
protected function load()
    {
        if (!$this->isConfigurationLoaded) {
            $this->values = $this->getDefaults();
            $values = $this->getConfigStore()->load();
            if (is_array($values)) {
                $this->values = array_merge($this->getDefaults(), $values);
            }
            $this->values = $this->castValues($this->values);
            $this->isConfigurationLoaded = true;
        }
    }
283623
public void loadAndShow() {

        CmsRpcAction<CmsRenameInfoBean> infoAction = new CmsRpcAction<CmsRenameInfoBean>() {

            @Override
            public void execute() {

                start(0, true);
                CmsCoreProvider.getVfsService().getRenameInfo(m_structureId, this);
            }

            @Override
            protected void onResponse(CmsRenameInfoBean renameInfo) {

                stop(false);
                CmsRenameView view = new CmsRenameView(renameInfo, m_renameHandler);
                for (CmsPushButton button : view.getDialogButtons()) {
                    addButton(button);
                }
                setMainContent(view);
                view.setDialog(CmsRenameDialog.this);
                center();
            }
        };
        infoAction.execute();
    }
1362209
function load(target) {
      if (!loaded[target]) {
        var def = componentDirectory[target];
        // Initialize component, this won't cause an infinite loop because
        // we've already check that the componentDirectory is a DAG
        let requires = def.requires || [];
        return loaded[target] = Promise.all(requires.map(load)).then(deps => {
          let ctx = {};
          for (let i = 0; i < deps.length; i++) {
            ctx[def.requires[i]] = deps[i];
          }
          return new Promise((resolve, reject) => {
            try {
              resolve(def.setup.call(null, ctx));
            } catch (err) {
              reject(err);
            }
          }).catch(function(err) {
            debug(`error while loading component '${target}': ${err}`);
            throw err;
          });
        });
      }
      return loaded[target];
    }
297873
public static function view($type, $view)
    {
        if ($view !== null && View::exists($view) === false) {
            throw new Exception($view . ' view is not found', 2);
        }

        $callRender = array( '\\' . get_called_class(), 'render' . ucfirst($type) );

        switch ($type) {
            case 'error':
                self::$views[$type] = $view;
                App::on('error', $callRender);

                if (empty(self::$displayErrors)) {
                    self::$displayErrors = ini_get('display_errors');

                    function_exists('ini_set') && ini_set('display_errors', '0');
                }
                break;

            case 'classes':
            case 'performance':
                self::$views[$type] = $view;
                App::on('terminate', $callRender);
                break;

            case 'before':
                self::$views[$type] = $view;
                break;

            default:
                throw new Exception($type . ' is not valid event', 2);
        }
    }
689802
public function initialize()
    {
        parent::initialize();

        $this->eventsManager->attach('view:notFoundView', function ($event, \Phalcon\Mvc\ViewInterface $view) {
            if (!in_array($this->dispatcher->getActionName(), ['new', 'edit', 'show', 'index'])) {
                return false;
            }

            if ($view->getCurrentRenderLevel() == View::LEVEL_ACTION_VIEW) {
                $templatePath = implode(DIRECTORY_SEPARATOR, [dirname(__FILE__), 'Crud','']);

                $view->setViewsDir($templatePath);
                $view->setControllerViewPath('views');
                $view->setRenderLevel(View::LEVEL_ACTION_VIEW);

                $view->render('', $this->dispatcher->getActionName());
            }
        });
    }
707448
public function load($force = false)
    {
        if (!$this->checkExtraColumns()) {
            return;
        }

        if ($this->loaded && !$force) {
            return;
        }

        $this->data = $this->read();
        $this->loaded = true;
    }
835977
public function process()
	{
		$view = $this->getView();
		$context = $this->getContext();

		try
		{
			parent::process();
		}
		catch( \Aimeos\Client\Html\Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'client', $e->getMessage() ) );
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $error;
		}
		catch( \Aimeos\Controller\Frontend\Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'controller/frontend', $e->getMessage() ) );
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $error;
		}
		catch( \Aimeos\MShop\Plugin\Provider\Exception $e )
		{
			$errors = array( $context->getI18n()->dt( 'mshop', $e->getMessage() ) );
			$errors = array_merge( $errors, $this->translatePluginErrorCodes( $e->getErrorCodes() ) );

			$view->summaryErrorCodes = $e->getErrorCodes();
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $errors;
		}
		catch( \Aimeos\MShop\Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'mshop', $e->getMessage() ) );
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $error;
		}
		catch( \Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'client', 'A non-recoverable error occured' ) );
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $error;
			$this->logException( $e );
		}
	}
149969
protected function loadClient(): void
    {
        if (self::$client === null) {
            $options = $this->options;

            if (!isset($options['servlet_address'])) {
                throw new Exception\InvalidArgumentException(__METHOD__.' Missing required parameter servlet_address');
            }

            $connection = static::parseServletUrl($options['servlet_address']);

            $params = new ArrayObject([
                Client::PARAM_JAVA_HOSTS => $connection['servlet_host'],
                Client::PARAM_JAVA_SERVLET => $connection['servlet_uri'],
                Client::PARAM_JAVA_AUTH_USER => $connection['auth_user'],
                Client::PARAM_JAVA_AUTH_PASSWORD => $connection['auth_password'],
                Client::PARAM_JAVA_DISABLE_AUTOLOAD => $options['java_disable_autoload'],
                Client::PARAM_JAVA_PREFER_VALUES => $options['java_prefer_values'],
                Client::PARAM_JAVA_SEND_SIZE => $options['java_send_size'],
                Client::PARAM_JAVA_RECV_SIZE => $options['java_recv_size'],
                Client::PARAM_JAVA_LOG_LEVEL => $options['java_log_level'],
                Client::PARAM_XML_PARSER_FORCE_SIMPLE_PARSER => $options['force_simple_xml_parser'],
                Client::PARAM_USE_PERSISTENT_CONNECTION => $options['use_persistent_connection']
            ]);

            self::$client = new Client($params, $this->logger);

            // Added in order to work with custom exceptions
            self::getClient()->throwExceptionProxyFactory = new Proxy\DefaultThrowExceptionProxyFactory(self::$client, $this->logger);

            $this->bootstrap();
        }
    }
873250
private function load()
    {
        foreach ($this->resources as $key => $resource) {
            if (!$resource instanceof PuliResource) {
                $this->resources[$key] = $this->repo->get($resource);
            }
        }

        $this->loaded = true;
    }
684313
public function load($includeBase = true)
    {
        $annotations = $this->annotations();
        if ($includeBase) {
            $errors = [];
            foreach ($this->__adapters as $model) {
                $model->load();
            }
        }
        foreach ($annotations['methods'] as $method => $anns) {
            if (isset($anns['onLoad'])) {
                $this->$method($annotations['properties']);
            }
        }
        foreach ($annotations['properties'] as $prop => $anns) {
            if (isset($anns['Bitflag'])) {
                $this->$prop = new Bitflag(
                    (int)("{$this->$prop}"),
                    $anns['Bitflag']
                );
            }
        }
    }
808275
public function Run ($displayView = TRUE)
	{

		// Default to Route url processor if none is set

		if (!$this->urlProcessor)
		{
			$this->urlProcessor	= new Resource\Controller\URL\Route;
		}

		// Run url processor to work out the controller and action from URL

		$this->urlProcessor->Process ();

		// Set controller paths to look in

		$controllerPaths	= is_array ($this->controllerPath)? $this->controllerPath : [$this->controllerPath];

		// Look through paths to look for controller

		foreach ($controllerPaths as $controllerClass)
		{

			// Add module to the class path

			$controllerClass .= $this->controllerModule? '\\' . $this->controllerModule : NULL;

			// Check the controller and action exist

			if ($this->urlProcessor->findController ($controllerClass, $this->captureall))
			{
				break;
			}

		}

		// Error if the controller and action do not exist

		if (!class_exists ($this->urlProcessor->controller) || !method_exists ($this->urlProcessor->controller, $this->urlProcessor->action))
		{
			throw new Exception ('Invalid controller action: ' . $this->urlProcessor->controller . '\\' . $this->urlProcessor->action, 404);
		}

		// Create controller

		$controllerObj		= $this->urlProcessor->createController ($controllerClass);

		// Set controller module

		if ($this->controllerModule)
		{
			$controllerObj->module		= $this->controllerModule;
		}

		// Set controller view if none is set and one is set in the bootstrap

		if ($this->view && !$controllerObj->view)
		{
			$controllerObj->view	= $this->view;
		}

		// Set controller exception handler

		if ($this->useExceptionHandler)
		{
			set_exception_handler (array ($controllerObj, 'Exception'));
		}

		// If the controller action is public and is valid to call

		if (is_callable (array ($controllerObj, $controllerObj->action)) &&
			$controllerObj->isActionValid ())
		{

			// Call controller action

			$controllerObj->callAction ();

		}

		// Otherwise error 404

		else
		{
			throw new Exception ('Invalid controller action: ' . $controllerObj->controller . '\\' . $controllerObj->action, 404);
		}

		// Display view

		if ($displayView && $controllerObj->render)
		{
			$controllerObj->View ();
		}

		// Return controller

		return $controllerObj;

	}
995492
public static function load($_sky_name,$_sky_var = [],$_sky_return = false){
	
		$__prop = Loader::getName($_sky_name,'view');

		if(!file_exists($__prop->path)){
			Exceptions::showError('Server Error','Missing View File: '.$__prop->path);
			return;
		}
		// extract array to variable
		extract($_sky_var);

		ob_start();
		
		include $__prop->path;

		$__view = ob_get_contents();
		
		ob_end_clean();

		if($_sky_return){
			return $__view;
		}

		self::$temp .= $__view;
	}
34151
protected function loadViewThemeObject()
    {
        $env = Environment::get();
        $app = Facade::getFacadeApplication();
        $tmpTheme = $app->make(ThemeRouteCollection::class)
            ->getThemeByRoute($this->getViewPath());
        if (isset($tmpTheme[0])) {
            $this->themeHandle = $tmpTheme[0];
        }

        if ($this->themeHandle) {
            switch ($this->themeHandle) {
                case VIEW_CORE_THEME:
                    $this->themeObject = new \Concrete\Theme\Concrete\PageTheme();
                    $this->pkgHandle = false;
                    break;
                case 'dashboard':
                    $this->themeObject = new \Concrete\Theme\Dashboard\PageTheme();
                    $this->pkgHandle = false;
                    break;
                default:
                    if (!isset($this->themeObject)) {
                        $this->themeObject = PageTheme::getByHandle($this->themeHandle);
                        $this->themePkgHandle = $this->themeObject->getPackageHandle();
                    }

            }
            $this->themeAbsolutePath = $env->getPath(DIRNAME_THEMES.'/'.$this->themeHandle, $this->themePkgHandle);
            $this->themeRelativePath = $env->getURL(DIRNAME_THEMES.'/'.$this->themeHandle, $this->themePkgHandle);
        }
    }