Instantiates and returns the view class that will generate the
        actual context for this plugin.
193337
def get_view(self, request, view_class, opts=None):
        
        kwargs = {}
        if opts:
            if not isinstance(opts, dict):
                opts = opts.__dict__
        else:
            opts = {}

        if not view_class in VALID_MIXIN_OPTIONS:
            valid_options = view_class.__dict__.keys()
            for cls in view_class.__bases__:
                if cls != object:
                    valid_options += cls.__dict__.keys()
            VALID_MIXIN_OPTIONS[view_class] = valid_options

        for key in VALID_MIXIN_OPTIONS[view_class]:
            if key in opts:
                kwargs[key] = opts[key]
            elif hasattr(self, key):
                kwargs[key] = getattr(self, key)

        view = view_class(**kwargs)
        view.request = request
        view.kwargs = {}
        return view
912469
@Override
    public final V view() {
        if (this.view == null) {
            try {
                this.view = buildView();
            } catch (final CoreException ce) {
                LOGGER.log(UIMessages.CREATION_FAILURE, ce, this.getClass().getName());
                throw new CoreRuntimeException(ce);
            }
        }
        return this.view;
    }
773519
function(klass) {
        var view = get(this, 'parentView');
        var isOfType = klass instanceof Mixin ?
                       function(view) { return klass.detect(view); } :
                       function(view) { return klass.detect(view.constructor); };

        while (view) {
          if (isOfType(view)) { return view; }
          view = get(view, 'parentView');
        }
      }
920134
private static WebView createWebView(final Context context) {
        final WebView webView = new WebView(context);
        webView.getSettings().setSupportMultipleWindows(true);
        webView.setWebChromeClient(new WebChromeClient() {
            @Override
            public boolean onCreateWindow(final WebView view, final boolean isDialog, final boolean isUserGesture, final Message resultMsg) {
                final WebView.HitTestResult result = view.getHitTestResult();
                final String data = result.getExtra();
                if (data != null) {
                    final Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(data));
                    context.startActivity(browserIntent);
                }
                return false;
            }
        });
        return webView;
    }
1200749
def generate_create_view(self):
        """"""

        name = model_class_form(self.model + 'CreateView')
        create_args = dict(
            form_class=self.get_actual_form('create'),
            model=self.get_model_class,
            template_name=self.get_template('create'),
            permissions=self.view_permission('create'),
            permission_required=self.check_permission_required,
            login_required=self.check_login_required,
            inlineformset=self.inlineformset,
            success_url=reverse_lazy('{}-{}-list'.format(self.app, self.custom_postfix_url)),
            custom_form=self.createupdate_forms or self.custom_modelform,
            custom_postfix_url=self.custom_postfix_url
        )

        parent_classes = [self.get_createupdate_mixin(), CreateView]
        if self.custom_create_view_mixin:
            parent_classes.insert(0, self.custom_create_view_mixin)

        create_class = type(
            name,
            tuple(parent_classes),
            create_args
        )

        self.classes[name] = create_class
        return create_class
13825
def context_class(self):
        
        if 'context_class' not in self._cached_values:
            context_cls_name = getattr(self.settings, 'CONTEXT_CLASS', '')
            if context_cls_name:
                context_class = import_object(context_cls_name)
            else:
                context_class = Context
            self._cached_values['context_class'] = context_class
        return self._cached_values['context_class']
174031
@SuppressWarnings("unchecked")
    public V getView() {
        V result = null;
        if (viewName != null) {
            result = (V) viewProvider.getView(viewName);
        }
        return result;
    }
934995
private final function getViewExtensionFactory()
    {
        if (!$this->_viewExtensionFactory) {
            throw new RequiredDependencyException(sprintf(
                'View extension factory is not injected in class "%s".',
                __CLASS__
            ));
        }

        $this->injectContextToViewExtensionFactory($this->_viewExtensionFactory);

        return $this->_viewExtensionFactory;
    }
523053
private static function init_view()
    {
        static::$container->add_singleton(
            View::class,
            function (Container $hodl) {
                return $hodl->resolve(View::class);
            }
        );

        static::$container->alias(View::class, 'view');
    }
1310023
public static android.view.View createView(Context context, Class<?> screenType) {
    Layout screen = screenType.getAnnotation(Layout.class);
    if (screen == null) {
      throw new IllegalArgumentException(
          String.format("@%s annotation not found on class %s", Layout.class.getSimpleName(),
              screenType.getName()));
    }

    int layout = screen.value();
    return inflateLayout(context, layout);
  }
1117030
@SuppressWarnings("unused")
    public void showContextView() {
        if ((mForwardAnimatorSet != null && mForwardAnimatorSet.isRunning())
                || (mAnimationView != null && mAnimationView.isPlaying())
                || (mReverseAnimatorSet != null && mReverseAnimatorSet.isRunning())) {
            return;
        }
        if (mBaseContainer != null) {
            mBaseContainer.setVisibility(GONE);
        }
        if (mAnimationView != null) {
            mAnimationView.setAnimated(true);
        }
        if (mContextView != null) {
            mContextView.setVisibility(VISIBLE);
        }
    }
1300605
function Context(view, parentContext) {
  this.view = view || {};
  this.cache = {
    '.': this.view
  };
  this.parent = parentContext;

  // If parent context isn't passed, but the model has parents, build the chain
  this.initialize(view, parentContext);
  if (this.isModel(view)) {
    this.lastModel = view;
  } else if (parentContext) {
    this.lastModel = parentContext.lastModel;
  }
}
625824
def get_renderer_context(self):
        
        # Note: Additionally 'response' will also be added to the context,
        #       by the Response object.
        return {
            'view': self,
            'args': getattr(self, 'args', ()),
            'kwargs': getattr(self, 'kwargs', {}),
            'request': getattr(self, 'request', None),
            'extra_context': getattr(self, 'renderer_extra_context', {})
        }
567014
public function getView()
    {
        // If we don't have a prefix, just return the view.
        if (is_null($this->prefix)) {
            return $this->getBaseView();
        }

        // Set up modifiable variables.
        $view     = $this->concatViewAndPrefix($this->prefix, $this->view);
        $prefixes = clone $this->prefixes;

        $this->attempted($view);

        // Try to find a valid view.
        while (! view()->exists($view)) {
            // If we are out of prefixes and the view still isn't found, back out.
            if (is_null($this->prefix) && ! view()->exists($view)) {
                $view = null;
                break;
            }

            // Remove prefixes until we don't have any left.
            if ($prefixes->count() > 0) {
                $prefixes->pop();

                $prefixes     = $this->removeControllerFromPrefixes($prefixes);
                $this->prefix = $prefixes->count() > 0 ? $prefixes->implode('.') : null;
                $view         = $this->concatViewAndPrefix($this->prefix, $this->view);
            } else {
                $this->prefix = null;
                $view         = $this->view;
            }

            $this->attempted($view);
        }

        $this->view = $view;

        return $this->view;
    }
542808
def get_view(self):
        
        view = self.view
        if not view.is_initialized:
            view.initialize()
        if not view.proxy_is_active:
            view.activate_proxy()
        return view.proxy.widget
666054
public function getViewEngine()
    {
        if($this->app->exists(ViewEngineInterface::class)) {
            return $this->app->get(ViewEngineInterface::class);
        }
        $view = View::forge($this->web->view_dir);
        $this->app->set(ViewEngineInterface::class, $view, true);
        return $view;
    }
361184
public function getView()
	{
	    if (!$this->has('view')) {
	        // first load current module, then overwrite common view config.
	        $configs = Config::get('views', $this->getName(), true);
	        
	        if ($configs) {
	            $client  = ClientType::detectClientType();
	            if ($client === ClientType::PC) {
	                $config = isset($configs['pc']) ? $configs['pc'] : [];
	            } else {
	                $config = isset($configs[$client]) ? $configs[$client] : (isset($configs['mobile']) ? $configs['mobile'] : (isset($configs['pc']) ? $configs['pc'] : []));
	            }
	        } else {
	            $config = Config::get('view', $this->getName(), true);
	        }
	        
	        if (!isset($config['templatePath'])) {
	            $config['templatePath'] = $this->basePath . 'view';
	        }
	        if (!isset($config['compiledPath'])) {
	            $config['compiledPath'] = rtrim(Config::getStoragePath(), '/') . '/app/' . $this->getName() . '/view';
	            $config['compiledPath'] = str_replace('//', '/', $config['compiledPath']);
	        }
	        if (!isset($config['htmlPath'])) {
	            $config['htmlPath'] = rtrim(Config::getWebRootPath(), '/') . '/html/' . $this->getName();
	            $config['htmlPath'] = str_replace('//', '/', $config['htmlPath']);
	        }
	        
	        $object = new View($config);
	        $this->set('view', $object);
	    }
	    
	    return $this->get('view');
	}