Returns the currently valid layout template, or base pagelayout if
no layout was resolved.
768067
public function getLayoutTemplate(string $context = ViewInterface::CONTEXT_DEFAULT): ?string
    {
        $layoutView = $this->buildLayoutView($context);
        if (!$layoutView instanceof LayoutViewInterface) {
            return $this->getPageLayoutTemplate();
        }

        return $layoutView->getTemplate();
    }
594077
function () {
            var meta   = getOrDefault( this, 'props.meta', {} )
              , fields = meta.fields;

            if ( !t.isDefined( fields ) ) 
                return null;
            else 
                return this.renderLayout( meta.layout.grid );
        }
889318
public static function getLayout()
	{
		if(self::$pageLayout === null)
		{
			global $objPage;

			if($objPage !== null)
			{
				self::$pageLayout = \LayoutModel::findByPk($objPage->layout);
			}
		}

		return self::$pageLayout;
	}
1076011
final protected function getLayoutProvider()
    {
        $layout = LayoutProvider::getProvider();
        $layout->generateValueEvent->attachHandler(function ($elementName) {
            if (isset($this->leaves[$elementName])) {
                return $this->leaves[$elementName];
            }

            return null;
        });

        return $layout;
    }
496260
public function layout()
    {
        $exists = (boolean) isset($this->data['layout']);

        return $exists ? $this->data['layout'] : null;
    }
77145
function getLayout(layout) {
    if (!layoutCache.hasOwnProperty(layout)) {
      var layoutContents = false,
          layoutPath = path.join(
        path.isAbsolute(options.layoutPath) ?
          options.layoutPath : path.join(process.cwd(), options.layoutPath),
        layout
      );
      try {
        layoutContents = fs.readFileSync(layoutPath, 'utf8');
      } catch (err) {
        throw new PluginError(logFlag, 'Could not read layout: \'' + layoutPath + '\'\n');
      }
      layoutCache[layout] = {
        contents: layoutContents,
        path: layoutPath
      };
    }
    return layoutCache[layout];
  }
311259
function layoutResource(filePath, config) {

    filePath = filePath || this.page.template;
    var testFilePath = filePath + config.extOut;
    var stat = this.has_file(testFilePath);

    if (stat) {
      return filePath;
    }

  }
900268
static function LayoutTemplate(Layout $layout)
    {
        $folder = Path::Combine(PHINE_PATH, 'App/Phine/LayoutTemplates');
        $file = Path::Combine($folder, $layout->GetName());
        return Path::AddExtension($file, 'phtml');
    }
354307
def restore_layout(self, name, *args):
        

        layout = self.__layouts.get(name)
        if not layout:
            raise umbra.exceptions.LayoutExistError("{0} | '{1}' layout isn't registered!".format(
                self.__class__.__name__, name))

        LOGGER.debug("> Restoring layout '{0}'.".format(name))

        for component, profile in self.__container.components_manager:
            if profile.category == "QWidget" and component not in self.__container.visible_components:
                interface = self.__container.components_manager.get_interface(component)
                interface and interface.hide()

        self.__current_layout = name
        self.__container.centralWidget().setVisible(
            self.__settings.get_key("Layouts", "{0}_central_widget".format(name)).toBool())
        self.__container.restoreState(
            self.__settings.get_key("Layouts", "{0}_window_state".format(name)).toByteArray())
        self.__restore_geometry_on_layout_change and \
        self.__container.restoreGeometry(
            self.__settings.get_key("Layouts", "{0}_geometry".format(name)).toByteArray())
        self.layout_restored.emit(self.__current_layout)
        return True
241200
void setWorkbenchLayout(Layout layout) {
		validateNotNull(layout, "layout");

		if (this.layout == layout) {
			return;
		}

		requestTabIndex = getCurrentRequestTabIndex();

		Layout previousLayout = this.layout;
		this.layout = layout;

		componentMaximiser.unmaximiseComponent();
		removeAll();

		List<AbstractPanel> visiblePanels;
		switch (layout) {
		case FULL:
			visiblePanels = getTabbedStatus().getVisiblePanels();
			getTabbedStatus().hideAllTabs();
			visiblePanels.addAll(getTabbedWork().getVisiblePanels());
			getTabbedWork().hideAllTabs();
			visiblePanels.addAll(getTabbedSelect().getVisiblePanels());
			getTabbedSelect().hideAllTabs();
			getTabbedFull().setVisiblePanels(visiblePanels);
			updateFullLayout();
			this.add(getFullLayoutPanel());
			break;
		case EXPAND_SELECT:
		case EXPAND_STATUS:
		default:
			this.add(layout == Layout.EXPAND_STATUS ? createStatusPanelsSplit() : createSelectPanelsSplit());

			if (previousLayout == Layout.FULL) {
				visiblePanels = getTabbedFull().getVisiblePanels();
				getTabbedFull().hideAllTabs();
				getTabbedStatus().setVisiblePanels(visiblePanels);
				getTabbedWork().setVisiblePanels(visiblePanels);
				getTabbedSelect().setVisiblePanels(visiblePanels);

				setResponsePanelPosition(responsePanelPosition);
			}
			break;
		}

		this.validate();
		this.repaint();
	}
1081457
def get_default_layout(template, options)
      source_ext = Renderer.source_extension_for(template.source_path)
      options[:layout][source_ext] if options.key?(:layout)
    end
546097
function() {

		if (this._content == null) {

			var argument_value = this._argument.getValue();
			if (Lava.schema.DEBUG && argument_value && !Array.isArray(argument_value)) Lava.t("Include view expects to receive a template from it's argument");

			this._content = new Lava.system.Template(
				this._argument.getValue() || this._config.template || [],
				this._widget,
				this
			)

		}

		return this._content;

	}
406636
public function getCurrentLayout()
    {
        if (!$this->layout && $this->layoutNodeId) {
            $this->layout = $this->getStorage()->findForNodeOnSite($this->layoutNodeId, $this->layoutSiteId, true);
        }

        return $this->layout;
    }
1090573
def get_layout(self):
        
        if self.request.is_ajax():
            layout = ['modal', ]
        else:
            layout = ['static_page', ]

        if self.workflow_class.wizard:
            layout += ['wizard', ]

        return layout
432356
function resolveTemplate (tfiles, tfile, resolved, temp = '') {
    
    // If parent layout was called by a page directly (vs. through a child layout)
    // inject already resolved content with child `temp`
    if (resolved[tfile]) {
      return injectContent(resolved[tfile], temp);
    }
    
    // Process layout as prescribed
    else if (tfiles[tfile]) {
      
      // Lookup layout in tfiles tree
      let tdata = tfiles[tfile];
      
      // Combine parent-child on `temp` via `injectContent`
      temp = injectContent(tdata.contents.toString(), temp);
      
      // If this layout has a parent `layout` in front-matter, "lather, rinse, repeat"
      return tdata.layout ? resolveTemplate(tfiles, tdata.layout, resolved, temp) : temp;
    }
    else {
      return temp;
    }
  }
1017648
def invalid_layout?(layout)
      !document.data["layout"].nil? && layout.nil? && !(document.is_a? Bunto::Excerpt)
    end
730028
public function getLayout()
    {
        $page = $this->CurrentPage;
        $customTemplate = $this->Style ? '_'.$this->Style : '';
        $pageType = $page->ClassName ? '_'.$page->ClassName : '';
        $className = $this->ClassName;
        $templates = array(
            $className.$pageType.$customTemplate,
            $className.$customTemplate,
            $className.$pageType,
            $className,
            'DefaultPlacement'
        );
        $this->extend('updateLayout', $templates);
        return $this->renderWith($templates, $this->getController());
    }