This is used to display the title of the current object (normally a page) in the browser's titlebar.
2810
def browser_title(yield_title = nil)
      [
        yield_title,
        @meta.browser_title.presence || @meta.path,
        Refinery::Core.site_name
      ].reject(&:blank?).join(" - ")
    end
1073878
def title(custom_title_or_options = nil)
      case custom_title_or_options
      when Hash
        options = custom_title_or_options
      else
        options = {}
        custom_title = custom_title_or_options
      end

      title = custom_title
      catch(:exception) do
        title ||= t('.title', options.merge(throw: true))
      end

      provide(:page_title, title && title.html_safe) # "provide" already escapes
      content_tag(:h1, title) if title
    end
1296565
def title( self ):
        
        if ( self.currentMode() == XCalendarScene.Mode.Day ):
            return self.currentDate().toString('dddd, MMMM dd, yyyy')
        
        elif ( self.currentMode() == XCalendarScene.Mode.Week ):
            title = nativestring(self.minimumDate().toString('dddd, MMMM dd'))
            title += ' - '
            title += nativestring(self.maximumDate().toString('dddd, MMMM dd, yyyy'))
            return title
        
        elif ( self.currentMode() == XCalendarScene.Mode.Month ):
            return self.currentDate().toString('MMMM yyyy')
        
        else:
            return ''
988499
def title(self):
        
        if not self._title:
            return projex.text.pretty(self.name())
        return self._title
295326
def show(self):
        
        self.iren.Initialize()
        self.ren_win.SetSize(800, 800)
        self.ren_win.SetWindowName(self.title)
        self.ren_win.Render()
        self.iren.Start()
697237
def title(self, title=None):
        """"""

        if title is None:
            return self._title
        else:
            if not isinstance(title, str):
                raise TypeError("title must be str, not '%s'" % str(title))
            self._title = title
1181842
function () {
		var titleOffset = 0,
			title = this.title,
			subtitle = this.subtitle,
			options = this.options,
			titleOptions = options.title,
			subtitleOptions = options.subtitle,
			autoWidth = this.spacingBox.width - 44; // 44 makes room for default context button

		if (title) {
			title
				.css({ width: (titleOptions.width || autoWidth) + PX })
				.align(extend({ y: 15 }, titleOptions), false, 'spacingBox');
			
			if (!titleOptions.floating && !titleOptions.verticalAlign) {
				titleOffset = title.getBBox().height;

				// Adjust for browser consistency + backwards compat after #776 fix
				if (titleOffset >= 18 && titleOffset <= 25) {
					titleOffset = 15; 
				}
			}
		}
		if (subtitle) {
			subtitle
				.css({ width: (subtitleOptions.width || autoWidth) + PX })
				.align(extend({ y: titleOffset + titleOptions.margin }, subtitleOptions), false, 'spacingBox');
			
			if (!subtitleOptions.floating && !subtitleOptions.verticalAlign) {
				titleOffset = mathCeil(titleOffset + subtitle.getBBox().height);
			}
		}

		this.titleOffset = titleOffset; // used in getMargins
	}
331686
def page_title(options = {})
      object = options.fetch(:object, @meta)
      options.delete(:object)
      options = Refinery::Pages.page_title.merge(options)

      title = []
      objects = (options[:chain_page_title] and object.respond_to?(:ancestors)) ? [object.ancestors, object] : [object]

      objects.flatten.compact.each do |obj|
        obj_title = obj.title if obj.title

        # Only link when the object responds to a url method.
        if options[:link] && obj.respond_to?(:url)
          title << link_to(obj_title, obj.url)
        else
          title << obj_title
        end
      end

      final_title = title.pop
      if (options[:page_title][:wrap_if_not_chained] and title.empty?) and options[:page_title][:tag].present?
        css = " class='#{options[:page_title][:class]}'" if options[:page_title][:class].present?
        final_title = "<#{options[:page_title][:tag]}#{css}>#{final_title}</#{options[:page_title][:tag]}>"
      end

      if title.empty?
        final_title.to_s.html_safe
      else
        tag = "<#{options[:ancestors][:tag]} class='#{options[:ancestors][:class]}'>"
        tag << title.join(options[:ancestors][:separator])
        tag << options[:ancestors][:separator]
        tag << "</#{options[:ancestors][:tag]}>#{final_title}"
        tag.html_safe
      end
    end
1056787
def set_title(self, title: str, url: str = None) -> None:
        
        self.title = title
        self.url = url
775664
def titlepage(wobj)
      s = @epub.titlepage
      if !s.nil? && !wobj.nil?
        wobj.puts s
      end
    end
976594
function title( $contentObjectAttribute, $name = "login" )
    {
        $user = $this->objectAttributeContent( $contentObjectAttribute );

        $value = $user->attribute( $name );

        return $value;
    }
419321
def add(self, title, obj, **kwargs):
        
        is_class = inspect.isclass(obj)
        self._push(title=title,
                   view=obj,
                   class_name=obj.im_class.__name__ if not is_class else obj.__name__,
                   is_class=is_class,
                   **kwargs)
580418
def information_title_header_element(feature, parent):
    """"""
    _ = feature, parent  # NOQA
    header = information_title_header['string_format']
    return header.capitalize()
246113
def page(self, attr=None, fill=u' '):
        '''
        if attr is None:
            attr = self.attr
        if len(fill) != 1:
            raise ValueError
        info = CONSOLE_SCREEN_BUFFER_INFO()
        self.GetConsoleScreenBufferInfo(self.hout, byref(info))
        if info.dwCursorPosition.X != 0 or info.dwCursorPosition.Y != 0:
            self.SetConsoleCursorPosition(self.hout, self.fixcoord(0, 0))

        w = info.dwSize.X
        n = DWORD(0)
        for y in range(info.dwSize.Y):
            self.FillConsoleOutputAttribute(self.hout, attr, 
                                            w, self.fixcoord(0, y), byref(n))
            self.FillConsoleOutputCharacterW(self.hout, ord(fill[0]), 
                                             w, self.fixcoord(0, y), byref(n))

        self.attr = attr
910000
def title
      return @title if @title
      if matches = class_const(:TITLE_RE).match(page)
        @title = matches[1].to_s.strip
        title_processor
        @title = decode_entities(@title)
      end
    end
546443
function PageTitle(props) {
  const { activePage } = React.useContext(PageContext);

  if (!activePage) {
    throw new Error('Missing activePage.');
  }

  const title = pageToTitleI18n(activePage, props.t);

  return props.children(title);
}
764382
function _updateTitle() {
        var currentDoc          = DocumentManager.getCurrentDocument(),
            windowTitle         = brackets.config.app_title,
            currentlyViewedFile = MainViewManager.getCurrentlyViewedFile(MainViewManager.ACTIVE_PANE),
            currentlyViewedPath = currentlyViewedFile && currentlyViewedFile.fullPath,
            readOnlyString      = (currentlyViewedFile && currentlyViewedFile.readOnly) ? "[Read Only] - " : "";

        if (!brackets.nativeMenus) {
            if (currentlyViewedPath) {
                _$title.text(_currentTitlePath);
                _$title.attr("title", currentlyViewedPath);
                if (currentDoc) {
                    // dirty dot is always in DOM so layout doesn't change, and visibility is toggled
                    _$dirtydot.css("visibility", (currentDoc.isDirty) ? "visible" : "hidden");
                } else {
                    // hide dirty dot if there is no document
                    _$dirtydot.css("visibility", "hidden");
                }
            } else {
                _$title.text("");
                _$title.attr("title", "");
                _$dirtydot.css("visibility", "hidden");
            }

            // Set _$titleWrapper to a fixed width just large enough to accommodate _$title. This seems equivalent to what
            // the browser would do automatically, but the CSS trick we use for layout requires _$titleWrapper to have a
            // fixed width set on it (see the "#titlebar" CSS rule for details).
            _$titleWrapper.css("width", "");
            var newWidth = _$title.width();
            _$titleWrapper.css("width", newWidth);

            // Changing the width of the title may cause the toolbar layout to change height, which needs to resize the
            // editor beneath it (toolbar changing height due to window resize is already caught by EditorManager).
            var newToolbarHeight = _$titleContainerToolbar.height();
            if (_lastToolbarHeight !== newToolbarHeight) {
                _lastToolbarHeight = newToolbarHeight;
                WorkspaceManager.recomputeLayout();
            }
        }

        var projectRoot = ProjectManager.getProjectRoot();
        if (projectRoot) {
            var projectName = projectRoot.name;
            // Construct shell/browser window title, e.g. "• index.html (myProject) — Brackets"
            if (currentlyViewedPath) {
                windowTitle = StringUtils.format(WINDOW_TITLE_STRING_DOC, readOnlyString + _currentTitlePath, projectName, brackets.config.app_title);
                // Display dirty dot when there are unsaved changes
                if (currentDoc && currentDoc.isDirty) {
                    windowTitle = "• " + windowTitle;
                }
            } else {
                // A document is not open
                windowTitle = StringUtils.format(WINDOW_TITLE_STRING_NO_DOC, projectName, brackets.config.app_title);
            }
        }
        window.document.title = windowTitle;
    }