Fullscreen API （日本語訳）

◎要約

Fullscreen ~API 標準は、自身を~fullscreenに表示する要素~用の~APIを定義する。 ◎ The Fullscreen API standard defines an API for elements to display themselves fullscreen.

1. 各種用語

この仕様は、 `INFRA$r に依存する。 ◎ This specification depends on the Infra Standard. [INFRA]

この仕様に利用される各種用語のほとんどは、 `CSS$r, `DOM$r, `HTML$r, `WEBIDL$r による。 ◎ Most terminology used in this specification is from CSS, DOM, HTML, and Web IDL. [CSS] [DOM] [HTML] [WEBIDL]

【この訳に特有な表記規約】

◎表記記号

2. ~model

各 `要素$には， `~fullscreenか@ が結付けられる — それは、真偽値であり，他が言明されない限り ~F をとるとする。 ◎ All elements have an associated fullscreen flag. Unless stated otherwise it is unset.

各 `iframe$e `要素$には， `~iframe~fullscreenか@ が結付けられる — それは、真偽値であり，他が言明されない限り ~F をとるとする。 ◎ All iframe elements have an associated iframe fullscreen flag. Unless stated otherwise it is unset.

所与の`文書$ %文書の `~fullscreen要素@ は、次を満たす %要素は［在るならばそれらのうち最上層な【すなわち，最後の（最も手前に塗られる）】もの／無いならば ~NULL ］とする ⇒ ［ %要素 ~IN %文書の`上端~層$ ］~AND［ %要素の`~fullscreenか$ ~EQ ~T ］ ◎ All documents have an associated fullscreen element. The fullscreen element is the topmost element in the document’s top layer whose fullscreen flag is set, if any, and null otherwise.

各 `文書$には `処理待ち~fullscreen~event群@ が結付けられる。それは、［ ( `文字列$, `要素$ ) が成す`~tuple$ ］たちが成す`有順序~集合$であり，初期~時は空とする。【この集合を成す~itemどうしの同等性は、成分ごとの比較に基づくことになろう。】 ◎ All documents have an associated list of pending fullscreen events, which is an ordered set of (string, element) tuples. It is initially empty.

`要素を~fullscreen化する@ ~algoは、所与の ( %要素 ) に対し： ◎ To fullscreen an element:

%どこまで隠すか ~LET `最上層な~popover先祖を見出す$( %要素, ~NULL, ~F ) ◎ Let hideUntil be the result of running topmost popover ancestor given element, null, and false.
`ある所までの~popoverを隠す$( %要素の`~node文書$, %どこまで隠すか, ~F, ~T ) ◎ Run hide popovers until given element’s node document, hideUntil, false, and true.
%要素の`~fullscreenか$ ~SET ~T ◎ Set element’s fullscreen flag.
`上端~層から要素を即時に除去する$( %要素 ) ◎ Remove from the top layer immediately given element.
`上端~層に要素を追加する$( %要素 ) ◎ Add to the top layer given element.

`要素を~unfullscreenする@ ~algoは、所与の ( %要素 ) に対し：

%要素の`~fullscreenか$ ~SET ~F
~IF［ %要素は `iframe$e 要素である］ ⇒ %要素の`~iframe~fullscreenか$ ~SET ~F
%要素の`~keyboard~lockありか$ ~SET ~F
`上端~層から要素を即時に除去する$( %要素 )

◎ To unfullscreen an element,＼ unset element’s fullscreen flag, iframe fullscreen flag (if any), and keyboard lock flag,＼ and remove from the top layer immediately given element.

`文書を~unfullscreenする@ ~algoは、所与の ( %文書 ) に対し ⇒ %文書の`上端~層$を成す ~EACH( `要素$ %要素 ) に対し ⇒ ~IF［ %要素の`~fullscreenか$ ~EQ ~T ］ ⇒ `要素を~unfullscreenする$( %要素 ) ◎ To unfullscreen a document, unfullscreen all elements, within document’s top layer, whose fullscreen flag is set.

`~fullscreenから全部的に抜出る@ ~algoは、所与の ( `文書$ %文書 ) に対し： ◎ To fully exit fullscreen a document document, run these steps:

~IF［ %文書の`~fullscreen要素$ ~EQ ~NULL ］ ⇒ ~RET ◎ If document’s fullscreen element is null, terminate these steps.
%文書の`上端~層$を成す ~EACH( %要素 ) に対し ⇒ ~IF［ %要素の`~fullscreenか$ ~EQ ~T ］~AND［ %要素 ~NEQ %文書の`~fullscreen要素$ ］ ⇒ `要素を~unfullscreenする$( %要素 ) ◎ Unfullscreen elements whose fullscreen flag is set, within document’s top layer, except for document’s fullscreen element.
`~fullscreenから抜出る$( %文書 ) ◎ Exit fullscreen document.

`除去-時の手続き$は、所与の ( %除去された~node ) に対し： ◎ Whenever the removing steps run with a removedNode, run these steps:

%文書 ~LET %除去された~node の`~node文書$ ◎ Let document be removedNode’s node document.
%除去された~node の ~EACH( `~shadowも含めた広義-子孫$ %~node ) に対し，`~shadowも含めた~tree順序$で： ◎ Let nodes be removedNode’s shadow-including inclusive descendants that have their fullscreen flag set, in shadow-including tree order. ◎ For each node in nodes:
1. ~IF［ %~node の`~fullscreenか$ ~EQ ~F ］ ⇒ ~CONTINUE ◎ ↑
2. ~IF［ %~node ~EQ %文書の`~fullscreen要素$ ］ ⇒ `~fullscreenから抜出る$( %文書 ) ◎ If node is document’s fullscreen element, exit fullscreen document.
3. ~ELSE ⇒ `要素を~unfullscreenする$( %~node ) ◎ Otherwise, unfullscreen node.
4. ~IF［ %~node ~IN %文書の`上端~層$ ］ ⇒ `上端~層から要素を即時に除去する$( %~node ) ◎ If document’s top layer contains node, remove from the top layer immediately given node.
  
  注記： `上端~層$は，他の仕様から要素が追加されたり除去され得るので、 %~node は %文書の`~fullscreen要素$でないかもしれない。例えば、 %~node は開いている `dialog$e 要素にもなり得る。 ◎ Other specifications can add and remove elements from top layer, so node might not be document’s fullscreen element. For example, node could be an open dialog element.

`文書~unload時の片付け手続き$は、所与の ( %文書 ) に対し ⇒ `~fullscreenから全部的に抜出る$( %文書 ) ◎ Whenever the unloading document cleanup steps run with a document, fully exit fullscreen document.

`~fullscreenは~supportされて@ いるとは、それまでに確立された【すなわち、所与の時点で，~fullscreen化を防止するような】［利用者-選好, ~security~risk, ~platform制限］は無いことを~~意味する。 ◎ Fullscreen is supported if there is no previously-established user preference, security risk, or platform limitation.

`~fullscreen化~手続き@ は、所与の ( `文書$ %文書 ) に対し： ◎ To run the fullscreen steps for a document document, run these steps:

%処理待ち~event群 ~LET %文書の`処理待ち~fullscreen~event群$【の~clone】 ◎ Let pendingEvents be document’s list of pending fullscreen events.
%文書の`処理待ち~fullscreen~event群$を`空にする$ ◎ Empty document’s list of pending fullscreen events.
%処理待ち~event群を成す ~EACH( ~tuple ( %型, %要素 ) ) に対し： ◎ For each (type, element) in pendingEvents:
1. %~target ~LET ［次が満たされるならば %要素／ ~ELSE_ %文書］ ⇒ ［ %要素は`接続されて$いる］~AND［ %要素の`~node文書$ ~EQ %文書］ ◎ Let target be element if element is connected and its node document is document, and otherwise let target be document.
2. `~eventを発火する$( %~target, %型 ) — 次のように初期化して ⇒＃ `bubbles$m 属性 ~SET ~T, `composed$m 属性 ~SET ~T ◎ Fire an event named type, with its bubbles and composed attributes set to true, at target.

注記：この手続きは、 `HTML$r にて定義される`描画を更新する手続き＠~WAPI#update-the-rendering$【！`~event~loop$】に統合されている。 ◎ These steps integrate with the event loop defined in HTML. [HTML]

各`要素$には、 `~keyboard~lockありか@ が結付けられる — それは、真偽値であり，他が言明されない限り ~F とする。 ◎ All elements have an associated keyboard lock flag. Unless stated otherwise it is unset.

`文書$の `~keyboard~lock@ が作動中になるのは、その`~fullscreen要素$ %要素が次を満たすときであり，他のときは作動中にならない ⇒ ［ %要素 ~NEQ ~NULL ］~AND［ %要素の`~keyboard~lockありか$ ~EQ ~T ］ ◎ A document has keyboard lock active when its fullscreen element is not null and the fullscreen element’s keyboard lock flag is set, and inactive otherwise.

3. ~API

enum `FullscreenNavigationUI@I {
  `auto$l,
  `show$l,
  `hide$l
};

enum `FullscreenKeyboardLock@I {
  `browser@l,
  `none@l
};

dictionary `FullscreenOptions@I {
  `FullscreenKeyboardLock$I `keyboardLock@mb = "none";
  `FullscreenNavigationUI$I `navigationUI@mb = "auto";
};

partial interface `Element$I {
  `Promise$<`undefined$> `requestFullscreen$m(optional `FullscreenOptions$I %options = {});

  attribute `EventHandler$I `onfullscreenchange$m;
  attribute `EventHandler$I `onfullscreenerror$m;
};

partial interface `Document$I {
  [`LegacyLenientSetter$] readonly attribute `boolean$ `fullscreenEnabled$m;
  [`LegacyLenientSetter$, `Unscopable$] readonly attribute `boolean$ `fullscreen$m; // 歴史的

  `Promise$<`undefined$> `exitFullscreen$m();

  attribute `EventHandler$I `onfullscreenchange$m;
  attribute `EventHandler$I `onfullscreenerror$m;
};

partial interface mixin `DocumentOrShadowRoot$I {
  [`LegacyLenientSetter$] readonly attribute `Element$I? `fullscreenElement$m;
};

%promise = %element . `requestFullscreen([options])$m

%element を~fullscreenに表示する — 済んだ時点で %promise を解決する。 ◎ Displays element fullscreen and resolves promise when done.

%options の `navigationUI$mb ~memberが給されたときは、［ ~fullscreenが選好される間，~navi~UIを示すかどうか］を指示する： ◎ When supplied, options’s navigationUI member indicates whether showing navigation UI while in fullscreen is preferred or not.＼

`show$l に設定した場合、 ~screen空間を広くとるより~naviを平易にする方が選好される。 ◎ If set to "show", navigation simplicity is preferred over screen space,＼
`hide$l に設定した場合、 ~screen空間を広くとる方が選好される。 ◎ and if set to "hide", more screen space is preferred.＼
~UAは、いつでも，~appの選好より利用者-選好を尊守することにしてもかまわない。 ◎ User agents are always free to honor user preference over the application’s.＼
既定の値 `auto$l は、 ~appによる選好は無いことを指示する。 ◎ The default value "auto" indicates no application preference.

%options の `keyboardLock$mb ~memberが給されたときは、［給された~keyboard~lock~modeが適用されることになるかどうか］を指示する： ◎ When supplied, options’s keyboardLock member indicates whether the supplied keyboard lock mode will apply.

`browser$l に設定した場合、 `~keyboard~lock$は適用され得る。 ◎ If set to "browser", keyboard lock can be applied.
~UAは、いつでも，~appの選好より利用者-選好を尊守することにしてもかまわない。 ◎ User agents are always free to honor user preference over the application’s.＼
既定の値 `none$l は、 ~keyboard~lockは適用されないことを指示する。 ◎ The default value "none" indicates no keyboard lock is applied.

%document . `fullscreenEnabled$m

［次が満たされるならば ~T ／ ~ELSE_ ~F ］を返す ⇒ ［ %document は `要素$を~fullscreenに表示する能を備える］~AND［ `~fullscreenは~supportされて$いる］ ◎ Returns true if document has the ability to display elements fullscreen and fullscreen is supported, or false otherwise.

%promise = %document . `exitFullscreen()$m

%document の`~fullscreen要素$の~fullscreen表示-を停止する — 済んだ時点で %promise を解決する。 ◎ Stops document’s fullscreen element from being displayed fullscreen and resolves promise when done.

%document . `fullscreenElement$m

%document の`~fullscreen要素$を返す。 ◎ Returns document’s fullscreen element.

%shadowroot . `fullscreenElement$m

%shadowroot の`~fullscreen要素$を返す。 ◎ Returns shadowroot’s fullscreen element.

`~fullscreen要素~準備済み検査@ は、所与の ( `要素$ %要素 ) に対し ⇒ ~RET ~IS ~AND↓： ◎ A fullscreen element ready check for an element element returns true if all of the following are true, and false otherwise:

%要素は`接続されて$いる ◎ element is connected.
%要素の`~node文書$には `fullscreen$l `特能の利用は許容され$ている ◎ element’s node document is allowed to use the "fullscreen" feature.
［ %要素の`名前空間$el ~NEQ `~HTML名前空間$ ］~OR［ %要素の`~popover可視性~状態$ ~EQ `隠している$i ］ ◎ element namespace is not the HTML namespace or element’s popover visibility state is hidden.

`requestFullscreen(options)@m ~method~手続きは： ◎ The requestFullscreen(options) method steps are:

%処理待ち文書 ~LET コレの`~node文書$ ◎ Let pendingDoc be this’s node document.
%~promise ~LET `新たな~promise$ ◎ Let promise be a new promise.
~IF［ %処理待ち文書は`全部的に作動中$でない］ ⇒＃ `~promiseを却下する$( %~promise, `TypeError$E 例外 )； ~RET %~promise ◎ If pendingDoc is not fully active, then reject promise with a TypeError exception and return promise.
%~error ~LET ~IS ~NOT ~AND↓： ◎ Let error be false. ◎ If any of the following conditions are false, then set error to true:
- ~OR↓：
  - コレの`名前空間$el ~EQ `~HTML名前空間$
  - コレは~SVG `svg$e 要素である `SVG$r
  - コレは~MathML `math$e 要素である `MATHML$r
  ◎ This’s namespace is the HTML namespace or this is an SVG svg or MathML math element. [SVG] [MATHML]
- コレは `dialog$e 要素でない ◎ This is not a dialog element.
- `~fullscreen要素~準備済み検査$( コレ ) ~EQ ~T ◎ The fullscreen element ready check for this returns true.
- `~fullscreenは~supportされて$いる ◎ Fullscreen is supported.
- ［コレに`関連な大域~obj$は`一過な作動化を有して$いる］~OR［この~algoは、利用者が生成した方位~変更により誘発された~FN ］
  
  【~FN この用語は、 `SCREEN-ORIENTATION$r に定義されていたが，今や廃された。】
  ◎ This’s relevant global object has transient activation or the algorithm is triggered by a user generated orientation change.
~IF［ %~error ~EQ ~F ］ ⇒ `利用者-作動化を消費する$( %処理待ち文書に`関連な大域~obj$ ) ◎ If error is false, then consume user activation given pendingDoc’s relevant global object.

~RET %~promise — 加えて… ◎ Return promise,＼

…以下の手続きも`並列的$に走らす： ◎ and run the remaining steps in parallel.

~IF［ %~error ~EQ ~F ］： ◎ If error is false, then＼

%処理待ち文書の`~node~navigable$の`~top-level辿可能$navにて`作動中な文書$navの表示域の寸法を~resizeする — 任意選択で~FN %options[ "`navigationUI$mb" ] の値を織り込む下で： ◎ resize pendingDoc’s node navigable’s top-level traversable’s active document’s viewport’s dimensions, optionally taking into account options["navigationUI"]:

値	表示域の寸法
`hide@l	出力-機器の~screenの全部的な寸法 ◎ full dimensions of the screen of the output device
`show@l	出力-機器の~screenから［ ~UAが示す~page~navi~controlが占める部分］を除いた寸法 ◎ dimensions of the screen of the output device clamped to allow the user agent to show page navigation controls
`auto@l	他の行に挙げたいずれか — どの寸法かは、 ~UAが定義する ◎ user-agent defined, but matching one of the above

【~FN 織り込まない場合、 `auto$l であったかのように挙動すると思われる。】

加えて，任意選択で ⇒ 末端利用者~向けに、これを復帰する方法について~~述べる~messageを表示する ◎ Optionally display a message how the end user can revert this.

~ELIF［ ~NOT ~AND↓ ］… ◎ If any of the following conditions are false, then set error to true:
- コレの`~node文書$ ~EQ %処理待ち文書 ◎ This’s node document is pendingDoc.
- `~fullscreen要素~準備済み検査$( コレ ) ~EQ ~T ◎ The fullscreen element ready check for this returns true.
…ならば： ◎ If error is true:
1. %処理待ち文書の`処理待ち~fullscreen~event群$に ( `fullscreenerror$et, コレ ) を`付加する$set ◎ Append (fullscreenerror, this) to pendingDoc’s list of pending fullscreen events.
2. `~promiseを却下する$( %~promise, `TypeError$E 例外 ) ◎ Reject promise with a TypeError exception and＼
3. ~RET ◎ terminate these steps.
%~fullscreen要素~群 ~LET 新たな`有順序~集合$ ◎ Let fullscreenElements be an ordered set＼
%要素 ~LET コレ ◎ initially consisting of this.
~WHILE［ %要素 ~NEQ ~NULL ］：
1. %~fullscreen要素~群に %要素を`付加する$set
2. %要素 ~LET %要素の`~node~navigable$の`容器$nav
◎ While true: • Let last be the last item of fullscreenElements. • Let container be last’s node navigable’s container. • If container is null, then break. • Append container to fullscreenElements.
%~fullscreen要素~群を成す ~EACH( %要素 ) に対し： ◎ For each element in fullscreenElements:
1. %文書 ~LET %要素の`~node文書$ ◎ Let doc be element’s node document.
2. ~IF［ %要素 ~EQ %文書の`~fullscreen要素$ ］ ⇒ ~CONTINUE ◎ If element is doc’s fullscreen element, continue.
  
  注記：何も変化しない場合、観測器に通知する必要は無い。 ◎ No need to notify observers when nothing has changed.
3. ~IF［ %要素 ~EQ コレ］~AND［コレは `iframe$e `要素$である］ ⇒ %要素の`~iframe~fullscreenか$ ~SET ~T ◎ If element is this and this is an iframe element, then set element’s iframe fullscreen flag.
4. `要素を~fullscreen化する$( %要素 ) ◎ Fullscreen element within doc.
5. %文書の`処理待ち~fullscreen~event群$に ( `fullscreenchange$et, %要素 ) を`付加する$set ◎ Append (fullscreenchange, element) to doc’s list of pending fullscreen events.
注記：要素たちが~fullscreen化される順序は、観測され得ない — `~fullscreen化~手続き$は、 `~tree順序$で呼出されるので。【なぜ観測され得ない？】 ◎ The order in which elements are fullscreened is not observable, because run the fullscreen steps is invoked in tree order.
コレの`~keyboard~lockありか$ ~SET %options[ "`keyboardLock$mb" ] に応じて ⇒＃ `browser$l ならば ~T ／ `none$l ならば ~F ◎ Depending on the value of options["keyboardLock"]: ◎ • "browser" •• Set this’s keyboard lock flag. • "none" •• Unset this’s keyboard lock flag.
`~promiseを解決する$( %~promise ) ◎ Resolve promise with undefined.

注記： ~process外にある【？】`~navigable$での実装は、読者への宿題として残される。改善案があれば歓迎する。 ◎ Implementations with out-of-process navigables are left as an exercise to the reader. Input welcome on potential improvements.

`fullscreenEnabled@m 取得子~手続きは ⇒ ~RET ~IS［コレには `fullscreen$l `特能の利用は許容され$ている］~AND［ `~fullscreenは~supportされて$いる］ ◎ The fullscreenEnabled getter steps are to return true if this is allowed to use the "fullscreen" feature and fullscreen is supported, and false otherwise

`fullscreen@m 取得子~手続きは ⇒ ~RET ~IS［コレの`~fullscreen要素$ ~NEQ ~NULL ］ ◎ The fullscreen getter steps are to return false if this’s fullscreen element is null, and true otherwise.

注記：作者は、代わりに `fullscreenElement$m 属性を利用するように。 ◎ Use the fullscreenElement attribute instead.

`fullscreenElement@m 取得子~手続きは： ◎ The fullscreenElement getter steps are:

~IF［コレは`~shadow根$である］~AND［コレの`~host$は`接続されて$いない］ ⇒ ~RET ~NULL ◎ If this is a shadow root and its host is not connected, then return null.
%候補 ~LET コレの`~fullscreen要素$をコレに向けて`~targetし直す$ ◎ Let candidate be the result of retargeting fullscreen element against this.
~IF［ ( %候補, コレ ) は同じ`~tree$内にある］ ⇒ ~RET %候補 ◎ If candidate and this are in the same tree, then return candidate.
~RET ~NULL ◎ Return null.

次を満たす`文書$ %文書は `単純~fullscreen文書@ という ⇒ ［ %文書の`上端~層$内の`要素$のうち［ `~fullscreenか$ ~EQ ~T ］を満たすもの］の個数 ~EQ 1 ◎ A document is said to be a simple fullscreen document if there is exactly one element in its top layer that has its fullscreen flag set.

注記： `上端~層$内に 2 個の `要素$がある`文書$でも，`単純~fullscreen文書$になり得る。例えば、 `~fullscreen要素$に加えて，開いている `dialog$e 要素がある場合。 ◎ A document with two elements in its top layer can be a simple fullscreen document. For example, in addition to the fullscreen element there could be an open dialog element.

`~unfullscreenする文書を収集する@ ~algoは、所与の ( %文書 ) に対し： ◎ To collect documents to unfullscreen given doc, run these steps:

%文書~群 ~LET 新たな`有順序~集合$ ◎ Let docs be an ordered set＼ ↓ consisting of doc.
~WHILE 無条件
1. ~Assert： %文書の`~fullscreen要素$ ~NEQ ~NULL
2. %文書~群に %文書を`付加する$set
3. ~IF［ %文書は`単純~fullscreen文書$でない］ ⇒ ~BREAK
4. %容器 ~LET %文書の`~node~navigable$の`容器$nav
5. ~IF［ %容器 ~EQ ~NULL ］ ⇒ ~BREAK
6. ~IF［ %容器の`~iframe~fullscreenか$ ~EQ ~F 【！原文 set( ~T ) は誤り】］ ⇒ ~BREAK
7. %文書 ~SET %容器の`~node文書$
◎ While true: • Let lastDoc be docs’s last document. • Assert: lastDoc’s fullscreen element is not null. • If lastDoc is not a simple fullscreen document, break. • Let container be lastDoc’s node navigable’s container. • If container is null, then break. • If container’s iframe fullscreen flag is set, break. • Append container’s node document to docs.
~RET %文書~群 ◎ Return docs.

注記： %文書~群は，文書のうち［その`~fullscreen要素$が~unfullscreenされることになるもの］からなるが、その最後の文書 %文書の`上端~層$内には［ `~fullscreenか$ ~EQ ~T ］にされた`要素$が複数個あるかもしれない — その事例では、 %文書は依然として，~fullscreenであり続けることになる。 ◎ This is the set of documents for which the fullscreen element will be unfullscreened, but the last document in docs might have more than one element in its top layer with the fullscreen flag set, in which case that document will still remain in fullscreen.

`~fullscreenから抜出る@ ~algoは、所与の ( `文書$ %文書 ) に対し： ◎ To exit fullscreen a document doc, run these steps:

%~promise ~LET `新たな~promise$ ◎ Let promise be a new promise.
~IF［ %文書は`全部的に作動中$でない］~OR［ %文書の`~fullscreen要素$ ~EQ ~NULL ］ ⇒＃ `~promiseを却下する$( %~promise, `TypeError$E 例外 )； ~RET %~promise ◎ If doc is not fully active or doc’s fullscreen element is null, then reject promise with a TypeError exception and return promise.
%~resizeか ~LET ~F ◎ Let resize be false.
%文書~群 ~LET `~unfullscreenする文書を収集する$( %文書 ) ◎ Let docs be the result of collecting documents to unfullscreen given doc.
%~top-level文書 ~LET %文書の`~node~navigable$の`~top-level辿可能$navにて`作動中な文書$nav ◎ Let topLevelDoc be doc’s node navigable’s top-level traversable’s active document.
~IF［ %~top-level文書 ~IN %文書~群］~AND［ %~top-level文書は`単純~fullscreen文書$である］ ⇒＃ %文書 ~SET %~top-level文書； %~resizeか ~SET ~T ◎ If topLevelDoc is in docs, and it is a simple fullscreen document, then set doc to topLevelDoc and resize to true.
~IF［ %文書の`~fullscreen要素$は`接続されて$いない］： ◎ If doc’s fullscreen element is not connected:
1. %文書の`処理待ち~fullscreen~event群$に ( `fullscreenchange$et, %文書の`~fullscreen要素$ ) を`付加する$set ◎ Append (fullscreenchange, doc’s fullscreen element) to doc’s list of pending fullscreen events.
2. `要素を~unfullscreenする$( %文書の`~fullscreen要素$ ) ◎ Unfullscreen doc’s fullscreen element.
~RET %~promise — 加えて… ◎ Return promise,＼
…以下の手続きも`並列的$に走らす： ◎ and run the remaining steps in parallel.
1. `~screen方位を全部的に~unlockする手続き$( %文書 ) ◎ Run the fully unlock the screen orientation steps with doc.
2. ~IF［ %~resizeか ~EQ ~T ］ ⇒ %文書の表示域をその “通常の” 寸法に~resizeする ◎ If resize is true, resize doc’s viewport to its "normal" dimensions.
3. ~IF［ %文書の`~fullscreen要素$ ~EQ ~NULL ］ ⇒＃ `~promiseを解決する$( %~promise )； ~RET ◎ If doc’s fullscreen element is null, then resolve promise with undefined and terminate these steps.
4. %抜出る文書~群 ~LET `~unfullscreenする文書を収集する$( %文書 ) ◎ Let exitDocs be the result of collecting documents to unfullscreen given doc.
5. %子孫~文書~群 ~LET 新たな`有順序~集合$ ◎ ↓
6. %文書の`子孫~navigable群$を成す ~EACH( %子孫 ) に対し【！in tree order は不要】 ⇒ ~IF［ %子孫にて`作動中な文書$navの`~fullscreen要素$ ~NEQ ~NULL ］ ⇒ %子孫~文書~群に %子孫にて`作動中な文書$navを`付加する$set ◎ Let descendantDocs be an ordered set consisting of doc’s descendant navigables' active documents whose fullscreen element is non-null, if any, in tree order.
7. %抜出る文書~群を成す ~EACH( %抜出る文書 ) に対し： ◎ For each exitDoc in exitDocs:
  1. %抜出る文書の`処理待ち~fullscreen~event群$に ( `fullscreenchange$et, %抜出る文書の`~fullscreen要素$ ) を`付加する$set ◎ Append (fullscreenchange, exitDoc’s fullscreen element) to exitDoc’s list of pending fullscreen events.
  2. ~IF［ %~resizeか ~EQ ~T ］ ⇒ `文書を~unfullscreenする$( %抜出る文書 ) ◎ If resize is true, unfullscreen exitDoc.
  3. ~ELSE ⇒ `要素を~unfullscreenする$( %抜出る文書の`~fullscreen要素$ ) ◎ Otherwise, unfullscreen exitDoc’s fullscreen element.
8. %子孫~文書~群を成す ~EACH( %子孫~文書 ) に対し： ◎ For each descendantDoc in descendantDocs:
  1. %子孫~文書の`処理待ち~fullscreen~event群$に ( `fullscreenchange$et, %子孫~文書の`~fullscreen要素$ ) を`付加する$set ◎ Append (fullscreenchange, descendantDoc’s fullscreen element) to descendantDoc’s list of pending fullscreen events.
  2. `文書を~unfullscreenする$( %子孫~文書 ) ◎ Unfullscreen descendantDoc.
  注記：文書たちが~unfullscreenされる順序は、観測され得ない — `~fullscreen化~手続き$は、 `~tree順序$で呼出されるので。【なぜ観測され得ない？】 ◎ The order in which documents are unfullscreened is not observable, because run the fullscreen steps is invoked in tree order.
9. `~promiseを解決する$( %~promise ) ◎ Resolve promise with undefined.

`exitFullscreen()@m ~method~手続きは ⇒ ~RET `~fullscreenから抜出る$( コレ ) ◎ The exitFullscreen() method steps are to return the result of running exit fullscreen on this.

以下に挙げる各種`~event~handler$（および，対応する`~event~handler~event型$）は、［ `Element$I ／ `Document$I ］~objにより，`~event~handler~IDL属性$として~supportされるモノトスル： ◎ The following are the event handlers (and their corresponding event handler event types) that must be supported by Element and Document objects as event handler IDL attributes:

`~event~handler$	`~event~handler~event型$
`onfullscreenchange@m	`fullscreenchange@et
`onfullscreenerror@m	`fullscreenerror@et

注記：これらは、［ `ShadowRoot$I ／ `Window$I ］~objからは~supportされない。また、 `Element$I ~obj用の対応する`~event~handler内容~属性$も無い — 名前空間を問わず。 ◎ These are not supported by ShadowRoot or Window objects, and there are no corresponding event handler content attributes for Element objects in any namespace.

4. ~UI

~UAには、 ~native媒体の~fullscreen制御を［ `requestFullscreen()$m, `exitFullscreen()$m ］【用に定義された手続き】を通して実装することが奨励される。 ◎ User agents are encouraged to implement native media fullscreen controls in terms of requestFullscreen() and exitFullscreen().

利用者が`閉-要請$を起動した場合、 `閉-要請~手続き$の一部として`~fullscreenから全部的に抜出る$ ~algoが誘発されることになる。これは、どの`閉-注視器$よりも優先される。 ◎ If the user initiates a close request, this will trigger the fully exit fullscreen algorithm as part of the close request steps. This takes precedence over any close watchers.

~UAは、［ `閉-要請$／ `exitFullscreen()$m の~call ］が無いときでも，必要yであると判断するならば ~fullscreen~sessionを終止してもヨイ。 ◎ The user agent may end any fullscreen session without a close request or call to exitFullscreen() whenever the user agent deems it necessary.

`~keyboard~lock$がいつ作動中かは、利用者に明瞭に通知されるベキである — 場合によっては、 ~browser~UI指示子を通して。 ◎ Users should be clearly notified when keyboard locking is active, possibly through browser UI indicators.

利用者~向けに［ ~keyboard~lock法を上書きして，制御を~systemや~UAへ戻すよう復帰する］ための単純かつ直感的な~methodがあるベキである。 ◎ There should be a simple and intuitive method for users to override keyboard locking, reverting control back to the system or user agent.

5. 描画

この節は、 `HTML$r `§ 具現化＠~HTMLrendering#rendering$と等価に解釈されることになる。 ◎ This section is to be interpreted equivalently to the Rendering section of HTML. [HTML]

5.1. `fullscreen^ps 疑似類

`fullscreen@ps `疑似類$は、 ~OR↓ を満たすどの`要素$ %要素にも合致するモノトスル： ◎ The :fullscreen pseudo-class must match any element element for which one of the following conditions is true:

%要素の`~fullscreenか$ ~EQ ~T ◎ element’s fullscreen flag is set.
［ %要素は`~shadow~host$である］~AND［［［ %要素の`~node文書$の`~fullscreen要素$ ］を %要素に向けて`~targetし直す$ ］~EQ %要素］ ◎ element is a shadow host and the result of retargeting its node document’s fullscreen element against element is element.

注記：これは、最上層な`~fullscreen要素$を返す `fullscreenElement$m ~APIとは異なる。 ◎ This makes it different from the fullscreenElement API, which returns the topmost fullscreen element.

5.2. ~UA~levelの既定の~stylesheet

@namespace "http://www.w3.org/1999/xhtml";

*|*:not(:root):fullscreen {
  position:fixed !important;
  inset:0 !important;
  margin:0 !important;
  box-sizing:border-box !important;
  min-width:0 !important;
  max-width:none !important;
  min-height:0 !important;
  max-height:none !important;
  width:100% !important;
  height:100% !important;
  transform:none !important;

  /* intentionally not !important */
  object-fit:contain;
}

iframe:fullscreen {
  border:none !important;
  padding:0 !important;
}

*|*:not(:root):fullscreen::backdrop {
  background:black;
}

6. ~keyboard~lock法

~keyboard~lock法は、 ~fullscreenにおいて稼働している~web~appの機能性を増補する。ある種の~UIkey入力 — 概して，~systemや~UAにより取扱われることになる入力 — を横取りすることを~appに許容することにより。これは、 `Esc^kbd や機能~UIkey【 `F1^kbd 等】の様な~UIkeyが当の~appの機能性に不可欠な局面 — ~game~appや~remote~desktop~appなど — において有用になる。 ◎ Keyboard locking enhances the functionality of web applications running in fullscreen by allowing them to intercept certain key inputs that would typically be handled by either the system or the user agent. This is useful in scenarios such as gaming or remote desktop applications, where keys like ESC or function keys are integral to the application’s functionality.

`~keyboard~lock$は、 ~UIkey入力を直に捕捉して — 概して，~UAや~OSにより実行される既定の挙動を素通りして — 取扱うことを~web~appに可能化する。通常は~UAや~system~levelの動作を誘発する~UIkey~eventは、代わりに~fullscreen内の~web~appへ~redirectされる。そのような（個々の~UIkeyや~keyboard~shortcut用の）~UIkey~eventは、 `~keyboard~lock$が作動中である間は，［その動作が無い］こともあれば［動作は有るが， `preventDefault$m を~callして動作を取消すことを~web~pageに許容する］こともある。 ◎ A keyboard lock enables web applications to capture and handle key inputs directly, bypassing the default behavior typically executed by the user agent or operating system. Key events that would normally trigger user agent or system-level actions are instead redirected to the web application in fullscreen. Such key events (for individual keys or keyboard shortcuts) may either have no action while keyboard lock is active, or it could still have the same action but allow the web page to call preventDefault() to cancel the action.

~UAは、 `文書$の`~keyboard~lock$が作動中から非~作動中へ変化したときは，［ ~keyboard~lockを非作動化して， ~keyboard入力の取扱いを~UAや~OSにおける既定の挙動へ復旧する］モノトスル。 ◎ Whenever a document’s keyboard lock is changed from active to inactive, user agents must deactivate the keyboard lock and restore the handling of keyboard inputs to the default behavior of the user agent and the operating system.

~UAは、［ ~fullscreenから抜出る目的］用に追加的な入力を予約するベキである。また、一部の — ~system~levelの — ~UIkeyたちが成す［連列／組合n ］は，~securityの理由から横取りし得ない。 ◎ User agents should reserve an additional input for the purposes of exiting fullscreen. There are also some system-level key sequences or combinations that cannot be intercepted for security reasons, such as Ctrl+Alt+Del on Windows.

例えば，~fullscreenから抜出るために `Esc^kbd ~UIkeyを利用する~UAは、 ~UIkeyが押されたとき即時に抜出ることを防止するために~keyboard~lockを利用して，代わりに~fullscreenを抜出るためには長押しを要求する。そのような~UAには、 ~fullscreenの~sessionに対し部分的な~keyboard~lockを暗黙的に是認するものもある — その事例では、 `Esc^kbd ~UIkeyは，明示的な~keyboard~lockにより影響される唯一の~UIkeyかもしれない【なぜ唯一？】。 ◎ For example, user agents that use the Esc key to exit fullscreen use keyboard lock to prevent immediate exit on key press, and instead require a long press to exit fullscreen. Some such user agents also implicitly grant partial keyboard lock to fullscreen session, in which case the Esc key might be the only key that is affected by explicit keyboard lock.

7. 許可~施策の統合

この仕様は、文字列 `fullscreen@l で識別される`施策により制御される特能$を定義する。その`既定の許容list$は、 `'self'^l とする。 ◎ This specification defines a policy-controlled feature identified by the string "fullscreen". Its default allowlist is 'self'.

注記： `文書$の`許可~施策$docは、その文書~内の内容は，~fullscreenにすることが許容されるかを決定する。文書~内で不能化された場合、文書~内のどの内容にも，~fullscreen`特能の利用は許容され$ない。 ◎ A document’s permissions policy determines whether any content in that document is allowed to go fullscreen. If disabled in any document, no content in the document will be allowed to use fullscreen.

~HTML `iframe$e 要素の `allowfullscreen$a 属性は、 `allow$a 属性により上書きされない限り，それが入子にしている文書の`容器~施策$に影響する。 ~iframe上に `allowfullscreen$a を設定することは， `<iframe allow="fullscreen *">^c と等価になる — `PERMISSIONS-POLICY-1$r の § `allowfullscreen^a に述べられるとおり。 ◎ The allowfullscreen attribute of the HTML iframe element affects the container policy for any document nested in that iframe. Unless overridden by the allow attribute, setting allowfullscreen on an iframe is equivalent to <iframe allow="fullscreen *">, as described in Permissions Policy § 6.3.1 allowfullscreen.

8. ~security／~privacyの考慮点

~UAは、重層するなどの手段により，末端利用者が［何かが~fullscreenで表示されていること］に気付けることを確保するべきである。 ~UAは、［ ~fullscreenから抜出るための，常に働く手段］を供して，利用者に告知するべきである。これは、ある~siteが［ ~fullscreenにある間、 ~UAや~OS環境までも~~模造して，末端利用者を欺く］ことを防止する。 `requestFullscreen()$m の定義も見よ。 ◎ User agents should ensure, e.g. by means of an overlay, that the end user is aware something is displayed fullscreen. User agents should provide a means of exiting fullscreen that always works and advertise this to the user. This is to prevent a site from spoofing the end user by recreating the user agent or even operating system environment when fullscreen. See also the definition of requestFullscreen().

`子~navigable$内の内容が~fullscreenになるのを可能化するためには、許可~施策を介して特定的に許容される必要がある — 次のいずれかを通して ⇒＃ ~HTML `iframe$e 要素の `allowfullscreen$a 属性／ ~HTML `iframe$e 要素の `allow$a 属性における適切な宣言／内容を入子にしている`文書$と伴に `Permissions-Policy$h ~HTTP~headerを送達する ◎ To enable content in a child navigable to go fullscreen, it needs to be specifically allowed via permissions policy, either through the allowfullscreen attribute of the HTML iframe element, or an appropriate declaration in the allow attribute of the HTML iframe element, or through a `Permissions-Policy` HTTP header delivered with the document through which it is nested.

これは例えば、［第三者-主体からの内容が，明示的な許可なく~fullscreenになる］のを防止する。 ◎ This prevents e.g. content from third parties to go fullscreen without explicit permission.

`~keyboard~lock$を適用するとき、この~APIを介して~lockし得る~UIkeyたちの組合nは，首に［ ~system制御や~privacy~riskを孕むもの（例：【~Windows における】 `Alt+Tab^kbd や `Ctrl+Alt+Del^kbd ）以外］に限られるよう制限される。 ◎ When applying a keyboard lock, only a limited set of keys, primarily those not involving system control or privacy risks (like Alt+Tab, Ctrl+Alt+Del), can be locked via the API.

~UAは、 `~keyboard~lock$を適用するときは，この特能の濫用を防止する防護策を実装するベキである — 当の~lockを上書きすることを利用者に許容するなど。 ◎ When applying a keyboard lock, user agents should implement safeguards to prevent abuse of this feature, such as allowing users to override the lock.

~UAは、 `~keyboard~lock$を無視する利用者-選好を供してもヨイ（任意の粒度で — 例：特定の~site用に, あるいは大域的に）。類似に，~keyboardを有さない~platformもあるかもしれない — そのような~platformにおいては、 ~UAは，`~keyboard~lock$の状態を無視してもヨイ。しかしながら，指紋収集を避けるため、これは，［ `requestFullscreen()$m ~methodその他の仕方で公開される~webに観測-可能な挙動］には影響するベキでない。 ◎ User agents may provide a user preference to ignore keyboard lock (with any granularity, e.g. for a specific site, or globally). Similarly, some platforms might not have a keyboard, where user agents may ignore the keyboard lock state. However, this should not affect the web-observable behavior of the requestFullscreen() method or be exposed in other ways, to avoid fingerprinting.

以前に~hostしていた定義

この仕様は、以前に［ `backdrop$pe, 文書の`上端~層$の概念］の定義を~hostしていた。 ◎ This specification previously hosted the definitions of ::backdrop and the concept of the document’s top layer.

謝辞

`_acks1@

知的財産権

`_ipr1@