Register the view finder implementation.

@return void
320041
public function registerViewFinder() {
        $this->app->bind('view.finder', function ($app) {
            $paths = $app['config']['view.paths'];

            return new FileViewFinder($app['files'], $paths);
        });
    }
115742
public function register()
    {
        $this->app->bindIf(IndexManagerInterface::class, DefaultManager::class);
        $this->app->resolving(DefaultManager::class, function(DefaultManager $manager) {
            $manager->addIndex(Page::class, PageIndex::class);
        });
    }
1126085
protected function registerViews()
    {
        $location = __DIR__ . '/../resources/views';

        $this->loadViewsFrom($location, $this->shortName);

        $this->publishes([
            $location => base_path('resources/views/vendor/' . $this->shortName),
        ], 'views');
    }
1211750
public function register()
    {
        $this->mergeConfigFrom(
            __DIR__.'/../config/eloquent-viewable.php',
            'eloquent-viewable'
        );

        $this->app->when(Views::class)
            ->needs(CacheRepository::class)
            ->give(function () : CacheRepository {
                return $this->app['cache']->store(config('eloquent-viewable.cache.store'));
            });

        $this->app->bind(ViewContract::class, View::class);

        $this->app->bind(CrawlerDetectAdapter::class, function ($app) {
            $detector = new CrawlerDetect(
                $app['request']->headers->all(),
                $app['request']->server('HTTP_USER_AGENT')
            );

            return new CrawlerDetectAdapter($detector);
        });

        $this->app->singleton(CrawlerDetectorContract::class, CrawlerDetectAdapter::class);
        $this->app->singleton(IpAddressResolverContract::class, IpAddressResolver::class);
        $this->app->singleton(HeaderResolverContract::class, HeaderResolver::class);
    }
244565
protected function registerEnvironment()
    {
        // Next we need to grab the engine resolver instance that will be used by the
        // environment. The resolver will be used by an environment to get each of
        // the various engine implementations such as plain PHP or Blade engine.
        $resolver = $this->container['view.engine.resolver'];
        $finder   = $this->container['view.finder'];
        $events   = $this->container['events'];
        $env      = new Environment($resolver, $finder, $events);

        // We will also set the container instance on this view environment since the
        // view composers may be classes registered in the container, which allows
        // for great testable, flexible composers for the application developer.
        $env->setContainer($this->container);

        return $env;
    }
855828
protected function registerBindings(): void
    {
        $this->app->bind('algolia.connection', function (Container $app) {
            $manager = $app['algolia'];

            return $manager->connection();
        });

        $this->app->alias('algolia.connection', SearchClient::class);
    }
12459
protected function registerViewComposers()
    {
        $this->app->extend('view', function (Factory $view) {
            $view->composer('fluxbb::layout.main', 'FluxBB\View\AlertsComposer');
            $view->composer('fluxbb::layout.main', 'FluxBB\View\GlobalsComposer');
            $view->composer('fluxbb::admin.layout.main', 'FluxBB\View\GlobalsComposer');

            return $view;
        });
    }
1302412
public function registerViewComposerData()
    {
        View::composer(
            'avored-framework::*',
            GlobalComposer::class
        );
        View::composer(
            'avored-framework::layouts.left-nav',
            AdminNavComposer::class
        );
        View::composer(
            'avored-framework::layouts.left-nav',
            AdminNavComposer::class
        );
        View::composer(
            'avored-framework::user.user._fields',
            UserFieldsComposer::class
        );
        View::composer(
            'avored-framework::system.site-currency._fields',
            SiteCurrencyFieldsComposer::class
        );
        View::composer(
            ['avored-framework::product.category.create', 'avored-framework::product.category.edit'],
            CategoryFieldsComposer::class
        );
        View::composer(
            'avored-framework::system.admin-user._fields',
            AdminUserFieldsComposer::class
        );
        View::composer(
            'avored-framework::cms.page._fields',
            PageFieldsComposer::class
        );
        View::composer(
            'avored-framework::cms.menu.index', 
            MenuComposer::class
        );
        View::composer(
            ['avored-framework::product.create', 'avored-framework::product.edit'], 
            ProductFieldsComposer::class
        );
    }
1031164
protected function registerViewPublisher(): void
    {
        $this->app->singleton('view.publisher', function (Application $app) {
            $viewPath = $app->basePath().'/resources/views';

            // Once we have created the view publisher, we will set the default packages
            // path on this object so that it knows where to find all of the packages
            // that are installed for the application and can move them to the app.
            $publisher = new View($app->make('files'), $viewPath);

            $publisher->setPackagePath($app->basePath().'/vendor');

            return $publisher;
        });
    }
648655
public function register()
    {
        $this->app->singleton('view', function($app)
        {
            // Next we need to grab the engine resolver instance that will be used by the
            // environment. The resolver will be used by an environment to get each of
            // the various engine implementations such as plain PHP or Blade engine.
            $resolver = $app['view.engine.resolver'];

            $finder = $app['view.finder'];

            $env = new LayoutView($resolver, $finder, $app['events']);

            // We will also set the container instance on this view environment since the
            // view composers may be classes registered in the container, which allows
            // for great testable, flexible composers for the application developer.
            $env->setContainer($app);

            $env->share('app', $app);

            return $env;
        });
    }
102192
public function registerViewComposerData()
    {
        View::composer('avored-ecommerce::layouts.left-nav', AdminNavComposer::class);
        View::composer('avored-ecommerce::site-currency._fields', SiteCurrencyFieldsComposer::class);
        View::composer(['avored-ecommerce::category._fields'], CategoryFieldsComposer::class);
        View::composer(['avored-ecommerce::admin-user._fields'], AdminUserFieldsComposer::class);
        View::composer(['avored-ecommerce::product.create',
                        'avored-ecommerce::product.edit',
                        ], ProductFieldsComposer::class);
    }
140618
public function registerHamlCompiler() {

		// Add resolver
		$this->app['view.engine.resolver']->register('haml', function() {
			return new CompilerEngine($this->app['Bkwld\LaravelHaml\HamlCompiler']);
		});

		// Add extensions
		$this->app['view']->addExtension('haml', 'haml');
		$this->app['view']->addExtension('haml.php', 'haml');
	}
300973
public function loadViews()
    {
        $package = $this->base_path."/Resources/views";

        $this->getServiceProvider()->loadViewsFrom($package, $this->name);
    }
715600
protected function registerClient()
    {
        $view = $this->getView();
        TreeViewAsset::register($view);

        $selector = ArrayHelper::remove($this->clientOptions, 'selector', 'ol.sortable');
        $view->registerJs("ns = $('{$selector}').nestedSortable(" . Json::htmlEncode($this->clientOptions) . ");");

        $treeView = $this->options['id'];
        $loading = $this->loadingOptions['id'];
        $view->registerJs(<<<JS
treeView = $('#{$treeView}');
loading = $('#{$loading}');
JS
        );
    }
272184
protected function registerViewPublisher()
	{
		$this->registerViewPublishCommand();

		$this->app->bindShared('view.publisher', function($app)
		{
			$viewPath = $app['path'].'/views';

			// Once we have created the view publisher, we will set the default packages
			// path on this object so that it knows where to find all of the packages
			// that are installed for the application and can move them to the app.
			$publisher = new ViewPublisher($app['files'], $viewPath);

			$publisher->setPackagePath($app['path.base'].'/vendor');

			return $publisher;
		});
	}
940302
public function registerViewFinder()
    {
        $this->app->bind('view.finder', function ($app) {

            // Create the FileViewFinder
            $paths = $app['config']['view.paths'];
            $fileViewfinder = new FileViewFinder($app['files'], $paths);

            // Create the VpageViewFinder
            $vpageViewFinder = new VpageViewFinder();

            // Create the ChainViewFinder
            $chainViewFinder = new ChainViewFinder();
            $chainViewFinder->addViewFinder($vpageViewFinder);
            $chainViewFinder->addViewFinder($fileViewfinder);

            return $chainViewFinder;
        });
    }
544446
public function registerFactory()
    {
        $this->app->singleton('view', function ($app) {
            // Next we need to grab the engine resolver instance that will be used by the
            // environment. The resolver will be used by an environment to get each of
            // the various engine implementations such as plain PHP or Blade engine.
            $resolver = $app['view.engine.resolver'];

            $finder = $app['view.finder'];

            $factory = $this->createFactory($resolver, $finder, $app['events']);

            // We will also set the container instance on this view environment since the
            // view composers may be classes registered in the container, which allows
            // for great testable, flexible composers for the application developer.
            $factory->setContainer($app);

            $factory->share('app', $app);

            return $factory;
        });
    }