Semantic MediaWiki and related extensions
Static Public Member Functions | Static Protected Attributes | List of all members
SMWOutputs Class Reference

Static Public Member Functions

static requireResource ( $moduleName)
static requireStyle ( $stylesName)
static requireScript ( $id, $script)
static requireHeadItem ( $id, $item='')
static requireFromParserOutput (ParserOutput $parserOutput)
static commitToParser (Parser $parser)
static commitToParserOutput (ParserOutput $parserOutput)
static commitToOutputPage (OutputPage $output)

Static Protected Attributes

static $headItems = []
static $scripts = []
static $resourceModules = []
static $resourceStyles = []

Detailed Description

This class attempts to provide safe yet simple means for managing data that is relevant for the final HTML output of MediaWiki. In particular, this concerns additions to the HTML header in the form of scripts of stylesheets.

The problem is that many components in SMW create hypertext that should eventually be displayed. The normal way of accessing such text are functions of the form getText() which return a (hypertext) string. Such a string, however, might refer to styles or scripts that are also needed. It is not possible to directly add those scripts to the MediaWiki output, since the form of this output depends on the context in which the function is called. Many functions might be called both during parsing and directly in special pages that do not use the usual parsing and caching mechanisms.

Ideally, all functions that generate hypertext with dependencies would also include parameters to record required scripts. Since this would require major API changes, the current solution is to have a "temporal" global storage for the required items, managed in this class. It is not safe to use such a global store across hooks – you never know what happens in between! Hence, every function that creates SMW outputs that may require head items must afterwards clear the temporal store by writing its contents to the according output.

Markus Krötzsch

Member Function Documentation

◆ commitToOutputPage()

static SMWOutputs::commitToOutputPage ( OutputPage  $output)

Actually commit the collected requirements to a given OutputPage object that will later generate the HTML output. This makes sure that HTML output contains all required output items. Note that there is no parser caching at this level of processing. In particular, data should not be committed to $wgOut in methods that run during page parsing, since these would not run next time when the page is produced from parser cache.


◆ commitToParser()

static SMWOutputs::commitToParser ( Parser  $parser)

Actually commit the collected requirements to a given parser that is about to parse what will later be the HTML output. This makes sure that HTML output based on the parser results contains all required output items.

If the parser creates output for a normal wiki page, then the committed items will also become part of the page cache so that they will correctly be added to all page outputs built from this cache later on.


TODO find out and document when this b/c code can go away

◆ commitToParserOutput()

static SMWOutputs::commitToParserOutput ( ParserOutput  $parserOutput)

Similar to SMWOutputs::commitToParser() but acting on a ParserOutput object.


◆ requireFromParserOutput()

static SMWOutputs::requireFromParserOutput ( ParserOutput  $parserOutput)

This function takes output requirements as can be found in a given ParserOutput object and puts them back in to the internal temporal requirement list from which they can be committed to some other output. It is needed when code that would normally call SMWOutputs::requireHeadItem() has need to use a full independent parser call (Parser::parse()) that produces its own parseroutput. If omitted, all output items potentially committed to this parseroutput during parsing will not be passed on to higher levels.

Note that this is not required if the $parseroutput is further processed by MediaWiki, but there are cases where the output is discarded and only its text is used.


TODO Is the following needed?

◆ requireHeadItem()

static SMWOutputs::requireHeadItem (   $id,
  $item = '' 

Adds head items that are not Resource Loader modules. Should only be used for custom head items such as RSS fedd links.

The id is used to avoid that the requirement for one script is recorded multiple times in SMWOutputs.

Support for calling this with the old constants SMW_HEADER_STYLE and SMW_HEADER_TOOLTIP will vanish in SMW 1.7 at the latest.


◆ requireResource()

static SMWOutputs::requireResource (   $moduleName)

Adds a resource module to the parser output.


◆ requireScript()

static SMWOutputs::requireScript (   $id,

Require the presence of header scripts, provided as strings with enclosing script tags. Note that the same could be achieved with requireHeadItems, but scripts use a special method "addScript" in MediaWiki OutputPage, hence we distinguish them.

The id is used to avoid that the requirement for one script is recorded multiple times in SMWOutputs.


◆ requireStyle()

static SMWOutputs::requireStyle (   $stylesName)

Member Data Documentation

◆ $headItems

SMWOutputs::$headItems = []

Protected member for temporarily storing header items. Format $id => $headItem where $id is used only to avoid duplicate items in the time before they are forwarded to the output.

◆ $scripts

SMWOutputs::$scripts = []

Protected member for temporarily storing additional Javascript snippets. Format $id => $scriptText where $id is used only to avoid duplicate scripts in the time before they are forwarded to the output.

The documentation for this class was generated from the following file:

About | General disclaimer | Privacy policy