2010-07-27 Jer Noble <jer.noble@apple.com>
authorjer.noble@apple.com <jer.noble@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 27 Aug 2010 20:49:02 +0000 (20:49 +0000)
committerjer.noble@apple.com <jer.noble@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 27 Aug 2010 20:49:02 +0000 (20:49 +0000)
        Reviewed by Eric Carlson.

        Add JavaScript API to allow a page to go fullscreen.
        rdar://problem/6867795
        https://bugs.webkit.org/show_bug.cgi?id=43099

        * wtf/Platform.h: Enable FULLSCREEN_API mode for the Mac (except iOS).
2010-07-27  Jer Noble  <jer.noble@apple.com>

        Reviewed by Eric Carlson.

        Add JavaScript API to allow a page to go fullscreen.
        rdar://problem/6867795

        Added chrome client overrides which support entering and exiting full screen.  A new preference has
        been added (setFullScreenEnabled:) to control at runtime whether full screen support is enabled
        (defaults to disabled).  Added a new WebKitFullScreenListener callback object which notifies WebCore
        when the chrome has started/finished its full screen animation.

        * Configurations/FeatureDefines.xcconfig:
        * WebCoreSupport/WebChromeClient.h:
        * WebCoreSupport/WebChromeClient.mm:
        (WebChromeClient::supportsFullscreenForElement):
        (WebChromeClient::enterFullscreenForElement):
        (WebChromeClient::exitFullscreenForElement):
        (-[WebKitFullScreenListener initWithElement:]):
        (-[WebKitFullScreenListener webkitWillEnterFullScreen]):
        (-[WebKitFullScreenListener webkitDidEnterFullScreen]):
        (-[WebKitFullScreenListener webkitWillExitFullScreen]):
        (-[WebKitFullScreenListener webkitDidExitFullScreen]):
        * WebView/WebPreferenceKeysPrivate.h:
        * WebView/WebPreferences.h:
        * WebView/WebPreferences.mm:
        (+[WebPreferences initialize]):
        (-[WebPreferences setFullScreenEnabled:]):
        (-[WebPreferences fullScreenEnabled]):
        * WebView/WebUIDelegatePrivate.h:
        * WebView/WebView.mm:
        (-[WebView _preferencesChangedNotification:]):
2010-07-27  Jer Noble  <jer.noble@apple.com>

        Reviewed by Eric Carlson.

        Add JavaScript API to allow a page to go fullscreen.
        rdar://problem/6867795
        https://bugs.webkit.org/show_bug.cgi?id=43099

        Mozilla has proposed a new set of JavaScript APIs which allow any element in
        a document to go full-screen.  The current revision of their proposal can be
        found here:
        <https://wiki.mozilla.org/index.php?title=Gecko:FullScreenAPI&oldid=243429>

        The proposed specification includes the following:

        Document:
        - Three new methods on Document:
            + void requestFullScreen()
            + void requestFullScreenWithKeys()
            + void cancelFullScreen()
        - Three new attributes of Document:
            + readonly attribute boolean fullScreen
            + readonly attribute boolean fullScreenWithKeys
            + (optional) readonly attribute Element currentFullScreenElement

        Element:
        - Two new methods on Element:
            + void requestFullScreen()
            + void requestFullScreenWithKeys()

        Events:
        - One new event:
            + fullScreenChange

        CSS Pseudo-classes:
        - Three new Pseudo-classes:
            + :full-screen
            + :full-screen-doc
            + :full-screen-root-with-target

        For WebKit's initial implementation, all the above new APIs will be prefixed with
        "webkit" or "-webkit" where appropriate.

        New tests:
        LayoutTests/fullscreen/full-screen-api.html
        LayoutTests/fullscreen/full-screen-css.html
        LayoutTests/fullscreen/full-screen-request.html

        Project file changes:
        * Configurations/FeatureDefines.xcconfig: Added an ENABLE_FULLSCREEN_API entry.
        * DerivedSources.make: Added rules for fullscreen.css and WebCore.FullScreen.exp.
        * WebCore.FullScreen.exp: Added export symbols for Document and Element functions.
        * WebCore.xcodeproj/project.pbxproj: New source files added to the project.

        IDL changes:
        * dom/Document.idl: Added the new full-screen API to the Document's javascript interface.
        * dom/Element.idl: Added the new full-screen API to the Element's javascript interface.

        Source changes:
        * bindings/objc/PublicDOMInterfaces.h: Exposed Document and Element fullscreen functions in the DOM classes.
        * css/CSSSelector.cpp: Added new FullScreen pseudo-classes.
        * css/CSSSelector.h: Added new full-screen pseudo classes to the PseudoType enum.
        * css/CSSStyleSelector.cpp:
        (WebCore::loadFullDefaultStyle): Pull the fullscreen.css sheet into the defaultStyle and the defaultQuirksStyle sheets.
        (WebCore::loadSimpleDefaultStyle): Pull the fullscreen.css sheet into the defaultStyle sheet.
        (WebCore::CSSStyleSelector::SelectorChecker::checkOneSelector): Check for the new FullScreen pseudo classes.
        * dom/Document.cpp:
        (WebCore::Document::createEvent): Support creating a "WebKitFullScreenChange" event.
        (WebCore::Document::addListenerTypeIfNeeded): Support listening for a "webKitFullScreenChangeEvent"
        (WebCore::Document::webkitRequestFullScreenForElement): Passes request to the chrome client to enter full screen mode.
        (WebCore::Document::webkitCancelFullScreen): Passes request to the chrome client to exit full screen mode.
        (WebCore::Document::webkitWillEnterFullScreenForElement): Sets the FullScreen pseudo-classes on the full-screen element and its document.
        (WebCore::Document::webkitDidEnterFullScreenForElement): Currently a no-op.
        (WebCore::Document::webkitWillExitFullScreenForElement): Currently a no-op.
        (WebCore::Document::webkitDidExitFullScreenForElement): Clears the FullScreen pseudo-classes on the full-screen element and its document.
        * dom/Document.h: Added const accessors for new full-screen instance variables.
        (WebCore::Document::):
        (WebCore::Document::webkitIsFullScreen): Accessor for m_isFullScreen.
        (WebCore::Document::webkitIsFullScreenWithKeysEnabled): Accessor for m_isFullScren and m_areKeysEnabled.
        (WebCore::Document::webkitCurrentFullScreenElement): Accessor for m_fullScreenElement.
        * dom/Element.cpp:
        (WebCore::Element::webkitRequestFullScreen): Calls Document::webkitRequestFullScreenForElement.
        * dom/Element.h:
        * dom/EventNames.h: Add a webkitfullscreenchange event name.
        * html/HTMLElement.cpp:
        (WebCore::HTMLElement::parseMappedAttribute): Parse the new "onwebkitfullscreenchange" attribute and register a listener.
        * page/ChromeClient.h:
        (WebCore::ChromeClient::supportsFullscreenForElement): Pass through to the current UI delegate.
        (WebCore::ChromeClient::enterFullscreenForElement): Create a WebKitFullScreenListener and pass through to the current UI delegate.
        (WebCore::ChromeClient::exitFullscreenForElement): Create a WebKitFullScreenListener and pass through to the current UI delegate.
        * page/Settings.cpp:
        (WebCore::Settings::Settings):
        * page/Settings.h: Add a new setting to control runtime support for full screen mode (defaults to off)
        * rendering/MediaControlElements.cpp:
        (WebCore::MediaControlFullscreenButtonElement::defaultEventHandler): The full screen button now toggles full screen mode (previously, it only entered).
        * rendering/style/RenderStyleConstants.h: Added new style constants.
2010-08-09  Jer Noble  <jer.noble@apple.com>

        Add JavaScript API to allow a page to go fullscreen.
        rdar://problem/6867795
        https://bugs.webkit.org/show_bug.cgi?id=43099

        New tests for the new full screen API:

        full-screen-api.html: tests for the presence of the new full screen
            apis.
        full-screen-request.html: tests that clients can request the browser
            enter full screen mode successfully.
        full-screen-css.html: tests that the new full screen pseudo classes are
            applied once full screen mode is entered.
        full-screen-remove.html: tests that the document's current full screen
            element is changed when that element is removed from the DOM tree.
        full-screen-remove-ancestor.html: tests that the document's current full
            screen element is changed an ancestor of that element is removed
            from the DOM tree.
        full-screen-twice.html: tests that entering full screen mode on two
            different elements in a row does not fail.

        Tests that were changed:

        domListEnumeration.html: This test returns a specific count of
            properties on HTML elements; after consultation with Sam Weinig (the
            original test author), it was decided that this part of the test
            would be very difficult to make platform specific, and that nothing
            significant would be lost if the property count sections were
            removed.

        platform/*/Skipped: Added the fullscreen/ directory to the Skipped list
            for every platform save mac.

        * fast/dom/Window/window-properties-expected.txt: Added the new
            properties exposed on Document and Element.
        * fast/dom/domListEnumeration-expected.txt: Removed the iteration count
            part of this test.
        * fast/dom/script-tests/domListEnumeration.js: ""
        * fullscreen: Added.
        * platform/mac/fullscreen: Added.
        * platform/mac/fullscreen/full-screen-api-expected.txt: Added.
        * platform/mac/fullscreen/full-screen-api.html: Added.
        * platform/mac/fullscreen/full-screen-css-expected.txt: Added.
        * platform/mac/fullscreen/full-screen-css.html: Added.
        * platform/mac/fullscreen/full-screen-remove-ancestor-expected.txt: Added.
        * platform/mac/fullscreen/full-screen-remove-ancestor.html: Added.
        * platform/mac/fullscreen/full-screen-remove-expected.txt: Added.
        * platform/mac/fullscreen/full-screen-remove.html: Added.
        * platform/mac/fullscreen/full-screen-request-expected.txt: Added.
        * platform/mac/fullscreen/full-screen-request.html: Added.
        * platform/mac/fullscreen/full-screen-twice-expected.txt: Added.
        * platform/mac/fullscreen/full-screen-twice.html: Added.
2010-07-27  Jer Noble  <jer.noble@apple.com>

        Reviewed by Eric Carlson.

        Add JavaScript API to allow a page to go fullscreen.
        rdar://problem/6867795

        Added basic full screen support to DumpRenderTree: when a webView requests
        that DumpRenderTree go "full screen", just call the provided callback listener object's
        will/did Enter/Exit full screen methods.  Also, register a new user default which
        enables full screen support.

        * DumpRenderTree/mac/DumpRenderTree.mm:
        (resetDefaultsToConsistentValues):
        * DumpRenderTree/mac/UIDelegate.mm:
        (-[UIDelegate webView:supportsFullscreenForElement:]):
        (-[UIDelegate webView:enterFullscreenForElement:listener:]):
        (-[UIDelegate webView:exitFullscreenForElement:listener:]):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@66251 268f45cc-cd09-0410-ab3c-d52691b4dbfc

64 files changed:
JavaScriptCore/ChangeLog
JavaScriptCore/wtf/Platform.h
LayoutTests/ChangeLog
LayoutTests/fast/dom/Window/window-properties-expected.txt
LayoutTests/fast/dom/domListEnumeration-expected.txt
LayoutTests/fast/dom/script-tests/domListEnumeration.js
LayoutTests/fullscreen/full-screen-api-expected.txt [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-api.html [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-css-expected.txt [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-css.html [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-remove-ancestor-expected.txt [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-remove-ancestor.html [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-remove-expected.txt [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-remove.html [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-request-expected.txt [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-request.html [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-test.js [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-twice-expected.txt [new file with mode: 0644]
LayoutTests/fullscreen/full-screen-twice.html [new file with mode: 0644]
LayoutTests/platform/android/Skipped [new file with mode: 0644]
LayoutTests/platform/chromium/Skipped [new file with mode: 0644]
LayoutTests/platform/google-chrome-linux64/Skipped [new file with mode: 0644]
LayoutTests/platform/gtk/Skipped
LayoutTests/platform/qt/Skipped
LayoutTests/platform/win/Skipped
WebCore/ChangeLog
WebCore/Configurations/FeatureDefines.xcconfig
WebCore/DerivedSources.make
WebCore/WebCore.exp.in
WebCore/WebCore.xcodeproj/project.pbxproj
WebCore/bindings/objc/PublicDOMInterfaces.h
WebCore/css/CSSPrimitiveValueMappings.h
WebCore/css/CSSSelector.cpp
WebCore/css/CSSSelector.h
WebCore/css/CSSStyleSelector.cpp
WebCore/css/CSSValueKeywords.in
WebCore/css/fullscreen.css [new file with mode: 0644]
WebCore/dom/Document.cpp
WebCore/dom/Document.h
WebCore/dom/Document.idl
WebCore/dom/Element.cpp
WebCore/dom/Element.h
WebCore/dom/Element.idl
WebCore/dom/EventNames.h
WebCore/html/HTMLAttributeNames.in
WebCore/html/HTMLElement.cpp
WebCore/page/ChromeClient.h
WebCore/page/Settings.cpp
WebCore/page/Settings.h
WebCore/platform/ThemeTypes.h
WebCore/rendering/MediaControlElements.cpp
WebCore/rendering/style/RenderStyleConstants.h
WebKit/mac/ChangeLog
WebKit/mac/Configurations/FeatureDefines.xcconfig
WebKit/mac/WebCoreSupport/WebChromeClient.h
WebKit/mac/WebCoreSupport/WebChromeClient.mm
WebKit/mac/WebView/WebPreferenceKeysPrivate.h
WebKit/mac/WebView/WebPreferences.mm
WebKit/mac/WebView/WebPreferencesPrivate.h
WebKit/mac/WebView/WebUIDelegatePrivate.h
WebKit/mac/WebView/WebView.mm
WebKitTools/ChangeLog
WebKitTools/DumpRenderTree/mac/DumpRenderTree.mm
WebKitTools/DumpRenderTree/mac/UIDelegate.mm

index dc436d5..196a2d0 100644 (file)
@@ -1,3 +1,13 @@
+2010-07-27  Jer Noble  <jer.noble@apple.com>
+
+        Reviewed by Eric Carlson.
+
+        Add JavaScript API to allow a page to go fullscreen.
+        rdar://problem/6867795
+        https://bugs.webkit.org/show_bug.cgi?id=43099
+
+        * wtf/Platform.h: Enable FULLSCREEN_API mode for the Mac (except iOS).
+
 2010-08-27  Gavin Barraclough  <barraclough@apple.com>
 
         Windows build fix pt 2.
index 2f27485..d58af31 100644 (file)
 #endif
 #define HAVE_READLINE 1
 #define HAVE_RUNLOOP_TIMER 1
+#define ENABLE_FULLSCREEN_API 1
 #endif /* PLATFORM(MAC) && !PLATFORM(IOS) */
 
 #if PLATFORM(MAC)
 #define ENABLE_ON_FIRST_TEXTAREA_FOCUS_SELECT_ALL 0
 #endif
 
+#if !defined(ENABLE_FULLSCREEN_API)
+#define ENABLE_FULLSCREEN_API 0
+#endif
+
 #if !defined(WTF_USE_JSVALUE64) && !defined(WTF_USE_JSVALUE32) && !defined(WTF_USE_JSVALUE32_64)
 #if (CPU(X86_64) && (OS(UNIX) || OS(WINDOWS))) \
     || (CPU(IA64) && !CPU(IA64_32)) \
index 8d08a0b..daee908 100644 (file)
@@ -1,3 +1,57 @@
+2010-08-09  Jer Noble  <jer.noble@apple.com>
+
+        Add JavaScript API to allow a page to go fullscreen.
+        rdar://problem/6867795
+        https://bugs.webkit.org/show_bug.cgi?id=43099
+
+        New tests for the new full screen API:
+
+        full-screen-api.html: tests for the presence of the new full screen 
+            apis.
+        full-screen-request.html: tests that clients can request the browser 
+            enter full screen mode successfully.
+        full-screen-css.html: tests that the new full screen pseudo classes are 
+            applied once full screen mode is entered.
+        full-screen-remove.html: tests that the document's current full screen 
+            element is changed when that element is removed from the DOM tree.
+        full-screen-remove-ancestor.html: tests that the document's current full 
+            screen element is changed an ancestor of that element is removed 
+            from the DOM tree.
+        full-screen-twice.html: tests that entering full screen mode on two     
+            different elements in a row does not fail.
+        
+        Tests that were changed:
+        
+        domListEnumeration.html: This test returns a specific count of 
+            properties on HTML elements; after consultation with Sam Weinig (the 
+            original test author), it was decided that this part of the test 
+            would be very difficult to make platform specific, and that nothing 
+            significant would be lost if the property count sections were 
+            removed.
+        
+        platform/*/Skipped: Added the fullscreen/ directory to the Skipped list 
+            for every platform save mac.
+
+        * fast/dom/Window/window-properties-expected.txt: Added the new 
+            properties exposed on Document and Element.
+        * fast/dom/domListEnumeration-expected.txt: Removed the iteration count 
+            part of this test.
+        * fast/dom/script-tests/domListEnumeration.js: ""
+        * fullscreen: Added.
+        * platform/mac/fullscreen: Added.
+        * platform/mac/fullscreen/full-screen-api-expected.txt: Added.
+        * platform/mac/fullscreen/full-screen-api.html: Added.
+        * platform/mac/fullscreen/full-screen-css-expected.txt: Added.
+        * platform/mac/fullscreen/full-screen-css.html: Added.
+        * platform/mac/fullscreen/full-screen-remove-ancestor-expected.txt: Added.
+        * platform/mac/fullscreen/full-screen-remove-ancestor.html: Added.
+        * platform/mac/fullscreen/full-screen-remove-expected.txt: Added.
+        * platform/mac/fullscreen/full-screen-remove.html: Added.
+        * platform/mac/fullscreen/full-screen-request-expected.txt: Added.
+        * platform/mac/fullscreen/full-screen-request.html: Added.
+        * platform/mac/fullscreen/full-screen-twice-expected.txt: Added.
+        * platform/mac/fullscreen/full-screen-twice.html: Added.
+
 2010-08-27  Mihai Parparita  <mihaip@chromium.org>
 
         Reviewed by Dimitri Glazkov.
index cca064f..e553bec 100644 (file)
@@ -43,6 +43,7 @@ window.Attr.prototype.replaceChild [function]
 window.Audio [object AudioConstructor]
 window.Audio.length [number]
 window.Audio.prototype [object HTMLAudioElementPrototype]
+window.Audio.prototype.ALLOW_KEYBOARD_INPUT [number]
 window.Audio.prototype.ATTRIBUTE_NODE [number]
 window.Audio.prototype.CDATA_SECTION_NODE [number]
 window.Audio.prototype.COMMENT_NODE [number]
@@ -123,6 +124,7 @@ window.Audio.prototype.setAttributeNS [function]
 window.Audio.prototype.setAttributeNode [function]
 window.Audio.prototype.setAttributeNodeNS [function]
 window.Audio.prototype.webkitMatchesSelector [function]
+window.Audio.prototype.webkitRequestFullScreen [function]
 window.BeforeLoadEvent [object BeforeLoadEventConstructor]
 window.BeforeLoadEvent.prototype [object BeforeLoadEventPrototype]
 window.BeforeLoadEvent.prototype.AT_TARGET [number]
@@ -636,6 +638,7 @@ window.Document.prototype.querySelectorAll [function]
 window.Document.prototype.removeChild [function]
 window.Document.prototype.removeEventListener [function]
 window.Document.prototype.replaceChild [function]
+window.Document.prototype.webkitCancelFullScreen [function]
 window.DocumentFragment [object DocumentFragmentConstructor]
 window.DocumentFragment.prototype [object DocumentFragmentPrototype]
 window.DocumentFragment.prototype.ATTRIBUTE_NODE [number]
@@ -715,7 +718,9 @@ window.DocumentType.prototype.removeChild [function]
 window.DocumentType.prototype.removeEventListener [function]
 window.DocumentType.prototype.replaceChild [function]
 window.Element [object ElementConstructor]
+window.Element.ALLOW_KEYBOARD_INPUT [number]
 window.Element.prototype [object ElementPrototype]
+window.Element.prototype.ALLOW_KEYBOARD_INPUT [number]
 window.Element.prototype.ATTRIBUTE_NODE [number]
 window.Element.prototype.CDATA_SECTION_NODE [number]
 window.Element.prototype.COMMENT_NODE [number]
@@ -780,6 +785,7 @@ window.Element.prototype.setAttributeNS [function]
 window.Element.prototype.setAttributeNode [function]
 window.Element.prototype.setAttributeNodeNS [function]
 window.Element.prototype.webkitMatchesSelector [function]
+window.Element.prototype.webkitRequestFullScreen [function]
 window.Entity [object EntityConstructor]
 window.Entity.prototype [object EntityPrototype]
 window.Entity.prototype.ATTRIBUTE_NODE [number]
index ea4524f..9ffb653 100644 (file)
@@ -32,7 +32,6 @@ PASS resultArray[2].i is '2'
 PASS resultArray[2].item is namedNodeMap.item(2)
 
 [object HTMLFormElement]
-PASS resultArray.length is 136
 PASS resultArray[0].i is '0'
 PASS resultArray[0].item is document.getElementsByTagName('select')[0]
 PASS resultArray[1].i is '1'
@@ -41,7 +40,6 @@ PASS resultArray[2].i is '2'
 PASS resultArray[2].item is document.getElementsByTagName('select')[2]
 
 [object HTMLSelectElement]
-PASS resultArray.length is 144
 PASS resultArray[0].i is '0'
 PASS resultArray[0].item is document.getElementsByTagName('option')[0]
 PASS resultArray[1].i is '1'
index b8d31ed..c1339e1 100644 (file)
@@ -130,7 +130,6 @@ shouldBe("resultArray[2].item", "namedNodeMap.item(2)");
 // HTMLFormElement
 var htmlFormElement = document.getElementsByTagName('form')[0];
 resultArray = iterateList(htmlFormElement);
-shouldBe("resultArray.length", "136");
 shouldBe("resultArray[0].i", "'0'");
 shouldBe("resultArray[0].item", "document.getElementsByTagName('select')[0]");
 shouldBe("resultArray[1].i", "'1'");
@@ -141,7 +140,6 @@ shouldBe("resultArray[2].item", "document.getElementsByTagName('select')[2]");
 // HTMLSelectElement
 var htmlSelectElement = document.getElementsByTagName('select')[0];
 resultArray = iterateList(htmlSelectElement);
-shouldBe("resultArray.length", "144");
 shouldBe("resultArray[0].i", "'0'");
 shouldBe("resultArray[0].item", "document.getElementsByTagName('option')[0]");
 shouldBe("resultArray[1].i", "'1'");
diff --git a/LayoutTests/fullscreen/full-screen-api-expected.txt b/LayoutTests/fullscreen/full-screen-api-expected.txt
new file mode 100644 (file)
index 0000000..9640804
--- /dev/null
@@ -0,0 +1,8 @@
+EXPECTED (document.webkitFullScreen == 'false') OK
+EXPECTED (document.webkitCancelFullScreen != 'undefined') OK
+EXPECTED (document.webkitCurrentFullScreenElement == 'null') OK
+EXPECTED (document.onwebkitfullscreenchange == 'null') OK
+EXPECTED (span.webkitRequestFullScreen != 'undefined') OK
+EXPECTED (span.onwebkitfullscreenchange == 'null') OK
+END OF TEST
+
diff --git a/LayoutTests/fullscreen/full-screen-api.html b/LayoutTests/fullscreen/full-screen-api.html
new file mode 100644 (file)
index 0000000..859e627
--- /dev/null
@@ -0,0 +1,13 @@
+<body>
+    <script src="full-screen-test.js"></script>
+<span></span>
+<script>
+    span = document.getElementsByTagName('span')[0];
+    testExpected("document.webkitFullScreen", false);
+    testExpected("document.webkitCancelFullScreen", undefined, "!=");
+    testExpected("document.webkitCurrentFullScreenElement", null);
+    testExpected("document.onwebkitfullscreenchange", null)
+    testExpected("span.webkitRequestFullScreen", undefined, "!=");
+    testExpected("span.onwebkitfullscreenchange", null) 
+    endTest();
+</script>
diff --git a/LayoutTests/fullscreen/full-screen-css-expected.txt b/LayoutTests/fullscreen/full-screen-css-expected.txt
new file mode 100644 (file)
index 0000000..ab993f8
--- /dev/null
@@ -0,0 +1,15 @@
+EXPECTED (document.defaultView.getComputedStyle(span, null).getPropertyValue('background-color') != 'rgb(0, 255, 0)') OK
+EXPECTED (document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('background-color') != 'rgb(255, 0, 0)') OK
+EXPECTED (document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('color') != 'rgb(0, 0, 255)') OK
+EVENT(webkitfullscreenchange)
+EXPECTED (document.webkitCurrentFullScreenElement == '[object HTMLElement]') OK
+EXPECTED (document.defaultView.getComputedStyle(span, null).getPropertyValue('background-color') == 'rgb(0, 255, 0)') OK
+EXPECTED (document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('background-color') == 'rgb(255, 0, 0)') OK
+EXPECTED (document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('color') == 'rgb(0, 0, 255)') OK
+EVENT(webkitfullscreenchange)
+EXPECTED (document.webkitCurrentFullScreenElement == '[object HTMLHtmlElement]') OK
+EXPECTED (document.defaultView.getComputedStyle(span, null).getPropertyValue('background-color') == 'rgb(0, 255, 0)') OK
+EXPECTED (document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('background-color') != 'rgb(255, 0, 0)') OK
+EXPECTED (document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('color') == 'rgb(0, 0, 255)') OK
+END OF TEST
+
diff --git a/LayoutTests/fullscreen/full-screen-css.html b/LayoutTests/fullscreen/full-screen-css.html
new file mode 100644 (file)
index 0000000..3115927
--- /dev/null
@@ -0,0 +1,50 @@
+<body>
+<script src="full-screen-test.js"></script>
+<style>
+    :-webkit-full-screen { background: lime; }
+    :-webkit-full-screen-document { color: blue; }
+    :root:-webkit-full-screen-document:not(:-webkit-full-screen) { background: red; }
+</style>
+<span></span>
+<script>
+    // Bail out early if the full screen API is not enabled or is missing:
+    if (Element.prototype.webkitRequestFullScreen == undefined) {
+        logResult(false, "Element.prototype.webkitRequestFullScreen == undefined");
+        endTest();
+    } else {
+        var callback;
+        var fullscreenChanged = function(event)
+        {
+            if (callback)
+                callback(event)
+        };
+        waitForEvent(document, 'webkitfullscreenchange', fullscreenChanged);
+
+        var span = document.getElementsByTagName('span')[0];
+    
+        testExpected("document.defaultView.getComputedStyle(span, null).getPropertyValue('background-color')", "rgb(0, 255, 0)", "!=");
+        testExpected("document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('background-color')", "rgb(255, 0, 0)", "!=");
+        testExpected("document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('color')", "rgb(0, 0, 255)", "!=");
+    
+        var spanEnteredFullScreen = function(event) {
+            testExpected("document.webkitCurrentFullScreenElement", span);
+            testExpected("document.defaultView.getComputedStyle(span, null).getPropertyValue('background-color')", "rgb(0, 255, 0)");
+            testExpected("document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('background-color')", "rgb(255, 0, 0)");
+            testExpected("document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('color')", "rgb(0, 0, 255)");
+        
+            callback = documentEnteredFullScreen;
+            document.documentElement.webkitRequestFullScreen();
+        };
+    
+        var documentEnteredFullScreen = function(event) {
+            testExpected("document.webkitCurrentFullScreenElement", document.documentElement);
+            testExpected("document.defaultView.getComputedStyle(span, null).getPropertyValue('background-color')", "rgb(0, 255, 0)");
+            testExpected("document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('background-color')", "rgb(255, 0, 0)", "!=");
+            testExpected("document.defaultView.getComputedStyle(document.documentElement, null).getPropertyValue('color')", "rgb(0, 0, 255)");
+            endTest();
+        };
+    
+        callback = spanEnteredFullScreen;
+        span.webkitRequestFullScreen();
+    }
+</script>
diff --git a/LayoutTests/fullscreen/full-screen-remove-ancestor-expected.txt b/LayoutTests/fullscreen/full-screen-remove-ancestor-expected.txt
new file mode 100644 (file)
index 0000000..d9a0ab3
--- /dev/null
@@ -0,0 +1,6 @@
+EVENT(webkitfullscreenchange)
+EXPECTED (document.webkitCurrentFullScreenElement == '[object HTMLElement]') OK
+EVENT(webkitfullscreenchange)
+EXPECTED (document.webkitCurrentFullScreenElement == '[object HTMLHtmlElement]') OK
+END OF TEST
+
diff --git a/LayoutTests/fullscreen/full-screen-remove-ancestor.html b/LayoutTests/fullscreen/full-screen-remove-ancestor.html
new file mode 100644 (file)
index 0000000..b072929
--- /dev/null
@@ -0,0 +1,36 @@
+<body>
+<script src="full-screen-test.js"></script>
+<div><span></span></div>
+<script>
+    // Bail out early if the full screen API is not enabled or is missing:
+    if (Element.prototype.webkitRequestFullScreen == undefined) {
+        logResult(false, "Element.prototype.webkitRequestFullScreen == undefined");
+        endTest();
+    } else {
+        var callback;
+        var fullscreenChanged = function(event)
+        {
+            if (callback)
+                callback(event)
+        };
+        waitForEvent(document, 'webkitfullscreenchange', fullscreenChanged);
+
+        var span = document.getElementsByTagName('span')[0];
+        var div = span.parentNode;
+
+        var spanEnteredFullScreen = function(event) {
+            callback = documentEnteredFullScreen;
+            testExpected("document.webkitCurrentFullScreenElement", span);
+            document.body.removeChild(div);
+        };
+
+        var documentEnteredFullScreen = function(event) {
+            callback = null;
+            testExpected("document.webkitCurrentFullScreenElement", document.documentElement);
+            endTest();
+        };
+
+        callback = spanEnteredFullScreen;
+        span.webkitRequestFullScreen();
+    }
+</script>
diff --git a/LayoutTests/fullscreen/full-screen-remove-expected.txt b/LayoutTests/fullscreen/full-screen-remove-expected.txt
new file mode 100644 (file)
index 0000000..d9a0ab3
--- /dev/null
@@ -0,0 +1,6 @@
+EVENT(webkitfullscreenchange)
+EXPECTED (document.webkitCurrentFullScreenElement == '[object HTMLElement]') OK
+EVENT(webkitfullscreenchange)
+EXPECTED (document.webkitCurrentFullScreenElement == '[object HTMLHtmlElement]') OK
+END OF TEST
+
diff --git a/LayoutTests/fullscreen/full-screen-remove.html b/LayoutTests/fullscreen/full-screen-remove.html
new file mode 100644 (file)
index 0000000..5a94bfd
--- /dev/null
@@ -0,0 +1,35 @@
+<body>
+<script src="full-screen-test.js"></script>
+<div><span></span></div>
+<script>
+    // Bail out early if the full screen API is not enabled or is missing:
+    if (Element.prototype.webkitRequestFullScreen == undefined) {
+        logResult(false, "Element.prototype.webkitRequestFullScreen == undefined");
+        endTest();
+    } else {
+        var callback;
+        var fullscreenChanged = function(event)
+        {
+            if (callback)
+                callback(event)
+        };
+        waitForEvent(document, 'webkitfullscreenchange', fullscreenChanged);
+    
+        var span = document.getElementsByTagName('span')[0];
+    
+        var spanEnteredFullScreen = function(event) {
+            callback = documentEnteredFullScreen;
+            testExpected("document.webkitCurrentFullScreenElement", span);
+            span.parentNode.removeChild(span);
+        };
+    
+        var documentEnteredFullScreen = function(event) {
+            callback = null;
+            testExpected("document.webkitCurrentFullScreenElement", document.documentElement);
+            endTest();
+        };
+    
+        callback = spanEnteredFullScreen;
+        span.webkitRequestFullScreen();
+    }
+</script>
diff --git a/LayoutTests/fullscreen/full-screen-request-expected.txt b/LayoutTests/fullscreen/full-screen-request-expected.txt
new file mode 100644 (file)
index 0000000..4bf81ef
--- /dev/null
@@ -0,0 +1,3 @@
+EVENT(webkitfullscreenchange) TEST(document.webkitFullScreen==true) OK
+END OF TEST
+
diff --git a/LayoutTests/fullscreen/full-screen-request.html b/LayoutTests/fullscreen/full-screen-request.html
new file mode 100644 (file)
index 0000000..2adb97f
--- /dev/null
@@ -0,0 +1,12 @@
+<body>
+<script src="full-screen-test.js"></script>
+<script>
+    // Bail out early if the full screen API is not enabled or is missing:
+    if (Element.prototype.webkitRequestFullScreen == undefined) {
+        logResult(false, "Element.prototype.webkitRequestFullScreen == undefined");
+        endTest();
+    } else {
+        waitForEventTestAndEnd(document, 'webkitfullscreenchange', "document.webkitFullScreen==true");
+        document.documentElement.webkitRequestFullScreen();
+    }
+</script>
diff --git a/LayoutTests/fullscreen/full-screen-test.js b/LayoutTests/fullscreen/full-screen-test.js
new file mode 100644 (file)
index 0000000..d37a80b
--- /dev/null
@@ -0,0 +1,119 @@
+var console = null;
+var printFullTestDetails = true; // This is optionaly switched of by test whose tested values can differ. (see disableFullTestDetailsPrinting())
+
+logConsole();
+
+if (window.layoutTestController) {
+    layoutTestController.dumpAsText();
+    layoutTestController.waitUntilDone();
+}
+
+function logConsole()
+{
+    if (!console && document.body) {
+        console = document.createElement('div');
+        document.body.appendChild(console);
+    }
+    return console;
+}
+
+function testAndEnd(testFuncString)
+{
+    test(testFuncString, true);
+}
+
+function test(testFuncString, endit)
+{
+    logResult(eval(testFuncString), "TEST(" + testFuncString + ")");
+    if (endit)
+        endTest();  
+}
+
+function testExpected(testFuncString, expected, comparison)
+{
+    try {
+        var observed = eval(testFuncString);
+    } catch (ex) {
+        consoleWrite(ex);
+        return;
+    }
+    
+    if (comparison === undefined)
+        comparison = '==';
+
+    var success = false;
+    switch (comparison)
+    {
+        case '<':  success = observed <  expected; break;
+        case '<=': success = observed <= expected; break;
+        case '>':  success = observed >  expected; break;
+        case '>=': success = observed >= expected; break;
+        case '!=': success = observed != expected; break;
+        case '==': success = observed == expected; break;
+    }
+    
+    reportExpected(success, testFuncString, comparison, expected, observed)
+}
+
+var testNumber = 0;
+
+function reportExpected(success, testFuncString, comparison, expected, observed)
+{
+    testNumber++;
+
+    var msg = "Test " + testNumber;
+
+    if (printFullTestDetails || !success)
+        msg = "EXPECTED (<em>" + testFuncString + " </em>" + comparison + " '<em>" + expected + "</em>')";
+
+    if (!success)
+        msg +=  ", OBSERVED '<em>" + observed + "</em>'";
+
+    logResult(success, msg);
+}
+
+function waitForEventAndEnd(eventName, funcString)
+{
+    waitForEvent(eventName, funcString, true)
+}
+
+function waitForEvent(element, eventName, func, endit)
+{
+    function _eventCallback(event)
+    {
+        consoleWrite("EVENT(" + eventName + ")");
+
+        if (func)
+            func(event);
+        
+        if (endit)
+            endTest();    
+    }
+
+    element.addEventListener(eventName, _eventCallback);
+}
+
+var testEnded = false;
+
+function endTest()
+{
+    consoleWrite("END OF TEST");
+    testEnded = true;
+    if (window.layoutTestController)
+        layoutTestController.notifyDone();     
+}
+
+function logResult(success, text)
+{
+    if (success)
+        consoleWrite(text + " <span style='color:green'>OK</span>");
+    else
+        consoleWrite(text + " <span style='color:red'>FAIL</span>");
+}
+
+function consoleWrite(text)
+{
+    if (testEnded)
+        return;
+    logConsole().innerHTML += text + "<br>";
+}
\ No newline at end of file
diff --git a/LayoutTests/fullscreen/full-screen-twice-expected.txt b/LayoutTests/fullscreen/full-screen-twice-expected.txt
new file mode 100644 (file)
index 0000000..d9a0ab3
--- /dev/null
@@ -0,0 +1,6 @@
+EVENT(webkitfullscreenchange)
+EXPECTED (document.webkitCurrentFullScreenElement == '[object HTMLElement]') OK
+EVENT(webkitfullscreenchange)
+EXPECTED (document.webkitCurrentFullScreenElement == '[object HTMLHtmlElement]') OK
+END OF TEST
+
diff --git a/LayoutTests/fullscreen/full-screen-twice.html b/LayoutTests/fullscreen/full-screen-twice.html
new file mode 100644 (file)
index 0000000..06485b8
--- /dev/null
@@ -0,0 +1,35 @@
+<body>
+<script src="full-screen-test.js"></script>
+<span></span>
+<script>
+    // Bail out early if the full screen API is not enabled or is missing:
+    if (Element.prototype.webkitRequestFullScreen == undefined) {
+        logResult(false, "Element.prototype.webkitRequestFullScreen == undefined");
+        endTest();
+    } else {
+        var callback;
+        var fullscreenChanged = function(event)
+        {
+            if (callback)
+                callback(event)
+        };
+        waitForEvent(document, 'webkitfullscreenchange', fullscreenChanged);
+    
+        var span = document.getElementsByTagName('span')[0];
+
+        var spanEnteredFullScreen = function() {
+            testExpected("document.webkitCurrentFullScreenElement", span);
+            callback = documentEnteredFullScreen;
+            document.documentElement.webkitRequestFullScreen();
+        };
+    
+        var documentEnteredFullScreen = function() {
+            testExpected("document.webkitCurrentFullScreenElement", document.documentElement);
+            callback = null;
+            endTest();
+        };
+
+        callback = spanEnteredFullScreen;
+        span.webkitRequestFullScreen();
+    }
+</script>
diff --git a/LayoutTests/platform/android/Skipped b/LayoutTests/platform/android/Skipped
new file mode 100644 (file)
index 0000000..f4ab335
--- /dev/null
@@ -0,0 +1,2 @@
+# Full Screen support is not yet enabled.
+fullscreen/
diff --git a/LayoutTests/platform/chromium/Skipped b/LayoutTests/platform/chromium/Skipped
new file mode 100644 (file)
index 0000000..f4ab335
--- /dev/null
@@ -0,0 +1,2 @@
+# Full Screen support is not yet enabled.
+fullscreen/
diff --git a/LayoutTests/platform/google-chrome-linux64/Skipped b/LayoutTests/platform/google-chrome-linux64/Skipped
new file mode 100644 (file)
index 0000000..f4ab335
--- /dev/null
@@ -0,0 +1,2 @@
+# Full Screen support is not yet enabled.
+fullscreen/
index 2d8b977..3a55904 100644 (file)
@@ -5945,3 +5945,6 @@ media/video-buffered.html
 
 # https://bugs.webkit.org/show_bug.cgi?id=44784
 fast/history/history-subframe-with-name.html
+
+# Full Screen support is not yet enabled.
+fullscreen/
index ded8ce1..e75e24d 100644 (file)
@@ -5447,3 +5447,5 @@ perf/
 # BlodBuilder is not enabled
 http/tests/local/blob/send-data-blob.html
 
+# Full Screen support is not yet enabled.
+fullscreen/
index 5485cb2..f803a34 100644 (file)
@@ -972,3 +972,6 @@ inspector/dom-breakpoints.html
 
 # <https://bugs.webkit.org/show_bug.cgi?id=44484>
 svg/batik/paints/patternRegions-positioned-objects.svg
+
+# Full Screen support is not yet enabled.
+fullscreen/
index dae300e..9c0619d 100644 (file)
@@ -1,3 +1,100 @@
+2010-07-27  Jer Noble  <jer.noble@apple.com>
+
+        Reviewed by Eric Carlson.
+
+        Add JavaScript API to allow a page to go fullscreen.
+        rdar://problem/6867795
+        https://bugs.webkit.org/show_bug.cgi?id=43099
+        
+        Mozilla has proposed a new set of JavaScript APIs which allow any element in
+        a document to go full-screen.  The current revision of their proposal can be 
+        found here:
+        <https://wiki.mozilla.org/index.php?title=Gecko:FullScreenAPI&oldid=243429>
+        
+        The proposed specification includes the following:
+        
+        Document:
+        - Three new methods on Document:
+            + void requestFullScreen()
+            + void requestFullScreenWithKeys()
+            + void cancelFullScreen()
+        - Three new attributes of Document:
+            + readonly attribute boolean fullScreen
+            + readonly attribute boolean fullScreenWithKeys
+            + (optional) readonly attribute Element currentFullScreenElement
+            
+        Element:
+        - Two new methods on Element:
+            + void requestFullScreen()
+            + void requestFullScreenWithKeys()
+        
+        Events:
+        - One new event:
+            + fullScreenChange
+        
+        CSS Pseudo-classes:
+        - Three new Pseudo-classes:
+            + :full-screen
+            + :full-screen-doc
+            + :full-screen-root-with-target
+        
+        For WebKit's initial implementation, all the above new APIs will be prefixed with 
+        "webkit" or "-webkit" where appropriate.
+        
+        New tests:
+        LayoutTests/fullscreen/full-screen-api.html
+        LayoutTests/fullscreen/full-screen-css.html
+        LayoutTests/fullscreen/full-screen-request.html
+
+        Project file changes:
+        * Configurations/FeatureDefines.xcconfig: Added an ENABLE_FULLSCREEN_API entry.
+        * DerivedSources.make: Added rules for fullscreen.css and WebCore.FullScreen.exp.
+        * WebCore.FullScreen.exp: Added export symbols for Document and Element functions.
+        * WebCore.xcodeproj/project.pbxproj: New source files added to the project.
+
+        IDL changes:
+        * dom/Document.idl: Added the new full-screen API to the Document's javascript interface.
+        * dom/Element.idl: Added the new full-screen API to the Element's javascript interface.
+
+        Source changes:
+        * bindings/objc/PublicDOMInterfaces.h: Exposed Document and Element fullscreen functions in the DOM classes.
+        * css/CSSSelector.cpp: Added new FullScreen pseudo-classes.
+        * css/CSSSelector.h: Added new full-screen pseudo classes to the PseudoType enum.
+        * css/CSSStyleSelector.cpp: 
+        (WebCore::loadFullDefaultStyle): Pull the fullscreen.css sheet into the defaultStyle and the defaultQuirksStyle sheets.
+        (WebCore::loadSimpleDefaultStyle): Pull the fullscreen.css sheet into the defaultStyle sheet.
+        (WebCore::CSSStyleSelector::SelectorChecker::checkOneSelector): Check for the new FullScreen pseudo classes.
+        * dom/Document.cpp:
+        (WebCore::Document::createEvent): Support creating a "WebKitFullScreenChange" event.
+        (WebCore::Document::addListenerTypeIfNeeded): Support listening for a "webKitFullScreenChangeEvent"
+        (WebCore::Document::webkitRequestFullScreenForElement): Passes request to the chrome client to enter full screen mode.
+        (WebCore::Document::webkitCancelFullScreen): Passes request to the chrome client to exit full screen mode.
+        (WebCore::Document::webkitWillEnterFullScreenForElement): Sets the FullScreen pseudo-classes on the full-screen element and its document.
+        (WebCore::Document::webkitDidEnterFullScreenForElement): Currently a no-op.
+        (WebCore::Document::webkitWillExitFullScreenForElement): Currently a no-op.
+        (WebCore::Document::webkitDidExitFullScreenForElement): Clears the FullScreen pseudo-classes on the full-screen element and its document.
+        * dom/Document.h: Added const accessors for new full-screen instance variables.
+        (WebCore::Document::):
+        (WebCore::Document::webkitIsFullScreen): Accessor for m_isFullScreen.
+        (WebCore::Document::webkitIsFullScreenWithKeysEnabled): Accessor for m_isFullScren and m_areKeysEnabled.
+        (WebCore::Document::webkitCurrentFullScreenElement): Accessor for m_fullScreenElement.
+        * dom/Element.cpp:
+        (WebCore::Element::webkitRequestFullScreen): Calls Document::webkitRequestFullScreenForElement. 
+        * dom/Element.h:
+        * dom/EventNames.h: Add a webkitfullscreenchange event name.
+        * html/HTMLElement.cpp:
+        (WebCore::HTMLElement::parseMappedAttribute): Parse the new "onwebkitfullscreenchange" attribute and register a listener.
+        * page/ChromeClient.h:
+        (WebCore::ChromeClient::supportsFullscreenForElement): Pass through to the current UI delegate.
+        (WebCore::ChromeClient::enterFullscreenForElement): Create a WebKitFullScreenListener and pass through to the current UI delegate.
+        (WebCore::ChromeClient::exitFullscreenForElement): Create a WebKitFullScreenListener and pass through to the current UI delegate.
+        * page/Settings.cpp:
+        (WebCore::Settings::Settings):
+        * page/Settings.h: Add a new setting to control runtime support for full screen mode (defaults to off)
+        * rendering/MediaControlElements.cpp:
+        (WebCore::MediaControlFullscreenButtonElement::defaultEventHandler): The full screen button now toggles full screen mode (previously, it only entered).
+        * rendering/style/RenderStyleConstants.h: Added new style constants.
+
 2010-08-27  James Robinson  <jamesr@chromium.org>
 
         Reviewed by Darin Fisher.
index f2b4c09..8f8c213 100644 (file)
@@ -71,6 +71,7 @@ ENABLE_FILTERS_macosx = ENABLE_FILTERS;
 
 ENABLE_FILE_WRITER = ;
 ENABLE_FILE_SYSTEM = ;
+ENABLE_FULLSCREEN_API = ENABLE_FULLSCREEN_API;
 ENABLE_GEOLOCATION = ENABLE_GEOLOCATION;
 
 ENABLE_ICONDATABASE = $(ENABLE_ICONDATABASE_$(REAL_PLATFORM_NAME));
@@ -120,4 +121,4 @@ ENABLE_XHTMLMP = ;
 ENABLE_XPATH = ENABLE_XPATH;
 ENABLE_XSLT = ENABLE_XSLT;
 
-FEATURE_DEFINES = $(ENABLE_LINK_PREFETCH) $(ENABLE_3D_CANVAS) $(ENABLE_3D_RENDERING) $(ENABLE_BLOB) $(ENABLE_CHANNEL_MESSAGING) $(ENABLE_CLIENT_BASED_GEOLOCATION) $(ENABLE_DATABASE) $(ENABLE_DATAGRID) $(ENABLE_DATALIST) $(ENABLE_DEVICE_ORIENTATION) $(ENABLE_DIRECTORY_UPLOAD) $(ENABLE_DOM_STORAGE) $(ENABLE_EVENTSOURCE) $(ENABLE_FILTERS) $(ENABLE_FILE_WRITER) $(ENABLE_FILE_SYSTEM) $(ENABLE_GEOLOCATION) $(ENABLE_ICONDATABASE) $(ENABLE_IMAGE_RESIZER) $(ENABLE_INDEXED_DATABASE) $(ENABLE_INPUT_SPEECH) $(ENABLE_JAVASCRIPT_DEBUGGER) $(ENABLE_MATHML) $(ENABLE_METER_TAG) $(ENABLE_NOTIFICATIONS) $(ENABLE_OFFLINE_WEB_APPLICATIONS) $(ENABLE_PROGRESS_TAG) $(ENABLE_RUBY) $(ENABLE_SANDBOX) $(ENABLE_SHARED_WORKERS) $(ENABLE_SVG) $(ENABLE_SVG_ANIMATION) $(ENABLE_SVG_AS_IMAGE) $(ENABLE_SVG_DOM_OBJC_BINDINGS) $(ENABLE_SVG_FONTS) $(ENABLE_SVG_FOREIGN_OBJECT) $(ENABLE_SVG_USE) $(ENABLE_VIDEO) $(ENABLE_WEB_SOCKETS) $(ENABLE_WEB_TIMING) $(ENABLE_WML) $(ENABLE_WORKERS) $(ENABLE_XHTMLMP) $(ENABLE_XPATH) $(ENABLE_XSLT);
+FEATURE_DEFINES = $(ENABLE_LINK_PREFETCH) $(ENABLE_3D_CANVAS) $(ENABLE_3D_RENDERING) $(ENABLE_BLOB) $(ENABLE_CHANNEL_MESSAGING) $(ENABLE_CLIENT_BASED_GEOLOCATION) $(ENABLE_DATABASE) $(ENABLE_DATAGRID) $(ENABLE_DATALIST) $(ENABLE_DEVICE_ORIENTATION) $(ENABLE_DIRECTORY_UPLOAD) $(ENABLE_DOM_STORAGE) $(ENABLE_EVENTSOURCE) $(ENABLE_FILTERS) $(ENABLE_FILE_WRITER) $(ENABLE_FILE_SYSTEM) $(ENABLE_FULLSCREEN_API) $(ENABLE_GEOLOCATION) $(ENABLE_ICONDATABASE) $(ENABLE_IMAGE_RESIZER) $(ENABLE_INDEXED_DATABASE) $(ENABLE_INPUT_SPEECH) $(ENABLE_JAVASCRIPT_DEBUGGER) $(ENABLE_MATHML) $(ENABLE_METER_TAG) $(ENABLE_NOTIFICATIONS) $(ENABLE_OFFLINE_WEB_APPLICATIONS) $(ENABLE_PROGRESS_TAG) $(ENABLE_RUBY) $(ENABLE_SANDBOX) $(ENABLE_SHARED_WORKERS) $(ENABLE_SVG) $(ENABLE_SVG_ANIMATION) $(ENABLE_SVG_AS_IMAGE) $(ENABLE_SVG_DOM_OBJC_BINDINGS) $(ENABLE_SVG_FONTS) $(ENABLE_SVG_FOREIGN_OBJECT) $(ENABLE_SVG_USE) $(ENABLE_VIDEO) $(ENABLE_WEB_SOCKETS) $(ENABLE_WEB_TIMING) $(ENABLE_WML) $(ENABLE_WORKERS) $(ENABLE_XHTMLMP) $(ENABLE_XPATH) $(ENABLE_XSLT);
index b9f6589..e7f000c 100644 (file)
@@ -676,6 +676,10 @@ ifeq ($(OS),MACOS)
 endif
 endif
 
+ifeq ($(findstring ENABLE_FULLSCREEN_API,$(FEATURE_DEFINES)), ENABLE_FULLSCREEN_API)
+    USER_AGENT_STYLE_SHEETS := $(USER_AGENT_STYLE_SHEETS) $(WebCore)/css/fullscreen.css
+endif
+
 UserAgentStyleSheets.h : css/make-css-file-arrays.pl $(USER_AGENT_STYLE_SHEETS)
        perl $< $@ UserAgentStyleSheetsData.cpp $(USER_AGENT_STYLE_SHEETS)
 
index 02b217a..0a8a510 100644 (file)
@@ -1475,6 +1475,13 @@ __ZN7WebCore9HTMLNames8audioTagE
 __ZN7WebCore9HTMLNames8videoTagE
 #endif
 
+#if ENABLE(FULLSCREEN_API)
+__ZN7WebCore8Document33webkitDidExitFullScreenForElementEPNS_7ElementE
+__ZN7WebCore8Document34webkitDidEnterFullScreenForElementEPNS_7ElementE
+__ZN7WebCore8Document34webkitWillExitFullScreenForElementEPNS_7ElementE
+__ZN7WebCore8Document35webkitWillEnterFullScreenForElementEPNS_7ElementE
+#endif
+
 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
 __ZN7WebCore23ApplicationCacheStorage14quotaForOriginEPKNS_14SecurityOriginERx
 __ZN7WebCore23ApplicationCacheStorage14setMaximumSizeEx
index 2ef816c..8c56f1c 100644 (file)
                C5EBDD81105EDDEC0056816F /* StorageEventDispatcher.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageEventDispatcher.h; sourceTree = "<group>"; };
                C6D74AD309AA282E000B0A52 /* ModifySelectionListLevel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ModifySelectionListLevel.h; sourceTree = "<group>"; };
                C6D74AE309AA290A000B0A52 /* ModifySelectionListLevel.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ModifySelectionListLevel.cpp; sourceTree = "<group>"; };
+               CD4E0AFA11F7BC27009D3811 /* fullscreen.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = fullscreen.css; sourceTree = "<group>"; };
                CE02F0C311E83ADD00C6684A /* ScriptControllerBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScriptControllerBase.h; sourceTree = "<group>"; };
                CE057FA31220731100A476D5 /* DocumentMarkerController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DocumentMarkerController.cpp; sourceTree = "<group>"; };
                CE057FA41220731100A476D5 /* DocumentMarkerController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DocumentMarkerController.h; sourceTree = "<group>"; };
                                BC9ADD220CC4032600098C4C /* WebKitCSSTransformValue.h */,
                                31611E540E1C4D4A00F6A579 /* WebKitCSSTransformValue.idl */,
                                4CDE54EC0E5579780089E26C /* wml.css */,
+                               CD4E0AFA11F7BC27009D3811 /* fullscreen.css */,
                        );
                        path = css;
                        sourceTree = "<group>";
index ea46436..428ac4a 100644 (file)
 - (DOMNodeList *)getElementsByClassName:(NSString *)tagname AVAILABLE_IN_WEBKIT_VERSION_4_0;
 - (DOMElement *)querySelector:(NSString *)selectors AVAILABLE_IN_WEBKIT_VERSION_4_0;
 - (DOMNodeList *)querySelectorAll:(NSString *)selectors AVAILABLE_IN_WEBKIT_VERSION_4_0;
+#if defined(ENABLE_FULLSCREEN_API) && ENABLE_FULLSCREEN_API
+- (void)webkitCancelFullScreen AVAILABLE_IN_WEBKIT_VERSION_4_0;
+#endif
 @end
 
 @interface DOMDocumentFragment : DOMNode WEBKIT_VERSION_1_3
 - (DOMNodeList *)getElementsByClassName:(NSString *)name AVAILABLE_IN_WEBKIT_VERSION_4_0;
 - (DOMElement *)querySelector:(NSString *)selectors AVAILABLE_IN_WEBKIT_VERSION_4_0;
 - (DOMNodeList *)querySelectorAll:(NSString *)selectors AVAILABLE_IN_WEBKIT_VERSION_4_0;
+#if defined(ENABLE_FULLSCREEN_API) && ENABLE_FULLSCREEN_API
+- (void)webkitRequestFullScreen:(unsigned short)flags AVAILABLE_IN_WEBKIT_VERSION_4_0;
+#endif
 @end
 
 @interface DOMEntity : DOMNode WEBKIT_VERSION_1_3
index b1d2d3d..8bfa93c 100644 (file)
@@ -262,6 +262,9 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
         case MediaControlsBackgroundPart:
             m_value.ident = CSSValueMediaControlsBackground;
             break;
+        case MediaControlsFullscreenBackgroundPart:
+            m_value.ident = CSSValueMediaControlsFullscreenBackground;
+            break;
         case MediaCurrentTimePart:
             m_value.ident = CSSValueMediaCurrentTimeDisplay;
             break;
index 1f336a2..fb8f695 100644 (file)
@@ -248,6 +248,13 @@ PseudoId CSSSelector::pseudoId(PseudoType type)
         return NOPSEUDO;
 #endif
 
+#if ENABLE(FULLSCREEN_API)
+    case PseudoFullScreen:
+        return FULL_SCREEN;
+    case PseudoFullScreenDocument:
+        return FULL_SCREEN_DOCUMENT;
+#endif
+            
     case PseudoInputListButton:
 #if ENABLE(DATALIST)
         return INPUT_LIST_BUTTON;
@@ -426,6 +433,10 @@ static HashMap<AtomicStringImpl*, CSSSelector::PseudoType>* nameToPseudoTypeMap(
     DEFINE_STATIC_LOCAL(AtomicString, firstPage, ("first"));
     DEFINE_STATIC_LOCAL(AtomicString, leftPage, ("left"));
     DEFINE_STATIC_LOCAL(AtomicString, rightPage, ("right"));
+#if ENABLE(FULLSCREEN_API)
+    DEFINE_STATIC_LOCAL(AtomicString, fullScreen, ("-webkit-full-screen"));
+    DEFINE_STATIC_LOCAL(AtomicString, fullScreenDocument, ("-webkit-full-screen-document"));
+#endif
 
     static HashMap<AtomicStringImpl*, CSSSelector::PseudoType>* nameToPseudoType = 0;
     if (!nameToPseudoType) {
@@ -537,6 +548,10 @@ static HashMap<AtomicStringImpl*, CSSSelector::PseudoType>* nameToPseudoTypeMap(
         nameToPseudoType->set(firstPage.impl(), CSSSelector::PseudoFirstPage);
         nameToPseudoType->set(leftPage.impl(), CSSSelector::PseudoLeftPage);
         nameToPseudoType->set(rightPage.impl(), CSSSelector::PseudoRightPage);
+#if ENABLE(FULLSCREEN_API)
+        nameToPseudoType->set(fullScreen.impl(), CSSSelector::PseudoFullScreen);
+        nameToPseudoType->set(fullScreenDocument.impl(), CSSSelector::PseudoFullScreenDocument);
+#endif
     }
     return nameToPseudoType;
 }
@@ -666,6 +681,10 @@ void CSSSelector::extractPseudoType() const
     case PseudoSingleButton:
     case PseudoNoButton:
     case PseudoNotParsed:
+#if ENABLE(FULLSCREEN_API)
+    case PseudoFullScreen:
+    case PseudoFullScreenDocument:
+#endif
         break;
     case PseudoFirstPage:
     case PseudoLeftPage:
index e253949..00e23b9 100644 (file)
@@ -217,6 +217,10 @@ namespace WebCore {
             PseudoLeftPage,
             PseudoRightPage,
             PseudoFirstPage,
+#if ENABLE(FULLSCREEN_API)
+            PseudoFullScreen,
+            PseudoFullScreenDocument,
+#endif
         };
 
         enum MarginBoxType {
index a595888..0ba63e0 100644 (file)
@@ -557,6 +557,14 @@ static void loadFullDefaultStyle()
     String quirksRules = String(quirksUserAgentStyleSheet, sizeof(quirksUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraQuirksStyleSheet();
     CSSStyleSheet* quirksSheet = parseUASheet(quirksRules);
     defaultQuirksStyle->addRulesFromSheet(quirksSheet, screenEval());
+    
+#if ENABLE(FULLSCREEN_API)
+    // Full-screen rules.
+    String fullscreenRules = String(fullscreenUserAgentStyleSheet, sizeof(fullscreenUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraDefaultStyleSheet();
+    CSSStyleSheet* fullscreenSheet = parseUASheet(fullscreenRules);
+    defaultStyle->addRulesFromSheet(fullscreenSheet, screenEval());
+    defaultQuirksStyle->addRulesFromSheet(fullscreenSheet, screenEval());
+#endif
 }
 
 static void loadSimpleDefaultStyle()
@@ -2635,6 +2643,26 @@ bool CSSStyleSelector::SelectorChecker::checkOneSelector(CSSSelector* sel, Eleme
                     break;
                 return true;
             }
+#if ENABLE(FULLSCREEN_API)
+            case CSSSelector::PseudoFullScreen:
+                // While a Document is in the fullscreen state, and the document's current fullscreen 
+                // element is an element in the document, the 'full-screen' pseudoclass applies to 
+                // that element. Also, an <iframe>, <object> or <embed> element whose child browsing 
+                // context's Document is in the fullscreen state has the 'full-screen' pseudoclass applied.
+                if (!e->document()->webkitFullScreen())
+                    return false;
+                if (e != e->document()->webkitCurrentFullScreenElement())
+                    return false;
+                return true;
+            case CSSSelector::PseudoFullScreenDocument:
+                // While a Document is in the fullscreen state, the 'full-screen-document' pseudoclass applies 
+                // to the root element of that Document.
+                if (!e->document()->webkitFullScreen())
+                    return false;
+                if (e != e->document()->documentElement())
+                    return false;
+                return true;
+#endif
             case CSSSelector::PseudoUnknown:
             case CSSSelector::PseudoNotParsed:
             default:
index d302990..56c6cc2 100644 (file)
@@ -585,6 +585,7 @@ media-volume-slider
 media-volume-sliderthumb
 media-volume-slider-mute-button
 media-controls-background
+media-controls-fullscreen-background
 media-current-time-display
 media-time-remaining-display
 menulist
diff --git a/WebCore/css/fullscreen.css b/WebCore/css/fullscreen.css
new file mode 100644 (file)
index 0000000..ebf3a02
--- /dev/null
@@ -0,0 +1,27 @@
+:-webkit-full-screen {
+    position:fixed;
+    top:0;
+    left:0;
+    right:0;
+    bottom:0;
+}
+
+:root:full-screen-document:not(:full-screen) {
+    overflow:hidden;
+}
+
+video:-webkit-full-screen {
+    width: 100%;
+    height: 100%
+    image-fit: fill;
+}
+
+img:-webkit-full-screen {
+    width: 100%;
+    height: 100%;
+    image-fit: fill;
+}
+
+video:-webkit-full-page-media:-webkit-full-screen::-webkit-media-controls-panel {
+    bottom: 0px;
+}
index 9e3c487..5d83474 100644 (file)
@@ -400,6 +400,10 @@ Document::Document(Frame* frame, const KURL& url, bool isXHTML, bool isHTML)
 #endif
     , m_weakReference(DocumentWeakReference::create(this))
     , m_idAttributeName(idAttr)
+#if ENABLE(FULLSCREEN_API)
+    , m_isFullScreen(0)
+    , m_areKeysEnabledInFullScreen(0)
+#endif
     , m_loadEventDelayCount(0)
 {
     m_document = this;
@@ -484,6 +488,9 @@ void Document::removedLastRef()
         m_activeNode = 0;
         m_titleElement = 0;
         m_documentElement = 0;
+#if ENABLE(FULLSCREEN_API)
+        m_fullScreenElement = 0;
+#endif
 
         // removeAllChildren() doesn't always unregister IDs, do it upfront to avoid having stale references in the map.
         m_elementsById.clear();
@@ -3235,6 +3242,19 @@ void Document::nodeWillBeRemoved(Node* n)
         frame->selection()->nodeWillBeRemoved(n);
         frame->dragCaretController()->nodeWillBeRemoved(n);
     }
+    
+#if ENABLE(FULLSCREEN_API)
+    // If the current full screen element or any of its ancestors is removed, set the current
+    // full screen element to the document root, and fire a fullscreenchange event to inform 
+    // clients of the DOM.
+    ASSERT(n);
+    if (n->contains(m_fullScreenElement.get())) {
+        ASSERT(n != documentElement());
+        m_fullScreenElement = documentElement();
+        m_fullScreenElement->setNeedsStyleRecalc();
+        m_fullScreenElement->dispatchEvent(Event::create(eventNames().webkitfullscreenchangeEvent, true, false));
+    }
+#endif
 }
 
 void Document::textInserted(Node* text, unsigned offset, unsigned length)
@@ -4648,6 +4668,70 @@ InspectorController* Document::inspectorController() const
     return page() ? page()->inspectorController() : 0;
 }
 #endif
+    
+#if ENABLE(FULLSCREEN_API)
+void Document::webkitRequestFullScreenForElement(Element* element, unsigned short flags)
+{
+    if (!page() || !page()->settings()->fullScreenEnabled())
+        return;
+
+    if (!element)
+        element = documentElement();
+    
+    if (!page()->chrome()->client()->supportsFullScreenForElement(element))
+        return;
+    
+    m_areKeysEnabledInFullScreen = flags & Element::ALLOW_KEYBOARD_INPUT;
+    page()->chrome()->client()->enterFullScreenForElement(element);
+}
+
+void Document::webkitCancelFullScreen()
+{
+    if (!page() || !m_fullScreenElement)
+        return;
+    
+    page()->chrome()->client()->exitFullScreenForElement(m_fullScreenElement.get());
+}
+    
+void Document::webkitWillEnterFullScreenForElement(Element* element)
+{
+    ASSERT(element);
+    ASSERT(page() && page()->settings()->fullScreenEnabled());
+
+    m_fullScreenElement = element;
+    m_isFullScreen = true;
+    documentElement()->setNeedsStyleRecalc(FullStyleChange);
+    m_fullScreenElement->setNeedsStyleRecalc(FullStyleChange);
+    updateStyleIfNeeded();
+    
+    m_fullScreenElement->dispatchEvent(Event::create(eventNames().webkitfullscreenchangeEvent, true, false));
+}
+    
+void Document::webkitDidEnterFullScreenForElement(Element*)
+{
+}
+
+void Document::webkitWillExitFullScreenForElement(Element*)
+{
+}
+
+void Document::webkitDidExitFullScreenForElement(Element* element)
+{
+    ASSERT(element);
+    m_isFullScreen = false;
+    m_areKeysEnabledInFullScreen = false;
+
+    // m_fullScreenElement has already been cleared; recalc the style of 
+    // the passed in element instead.
+    element->setNeedsStyleRecalc(FullStyleChange);
+    if (element != documentElement())
+        documentElement()->setNeedsStyleRecalc(FullStyleChange);
+    updateStyleIfNeeded();
+    
+    element->dispatchEvent(Event::create(eventNames().webkitfullscreenchangeEvent, true, false));
+}
+    
+#endif
 
 void Document::decrementLoadEventDelayCount()
 {
index 3381bea..4cfb6bc 100644 (file)
@@ -273,6 +273,9 @@ public:
     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchend);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchcancel);
 #endif
+#if ENABLE(FULLSCREEN_API)
+    DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitfullscreenchange);
+#endif
 
     DocumentType* doctype() const { return m_docType.get(); }
 
@@ -997,6 +1000,19 @@ public:
     MediaCanStartListener* takeAnyMediaCanStartListener();
 
     const QualifiedName& idAttributeName() const { return m_idAttributeName; }
+    
+#if ENABLE(FULLSCREEN_API)
+    bool webkitFullScreen() const { return m_isFullScreen; }
+    bool webkitFullScreenKeyboardInputAllowed() const { return m_isFullScreen && m_areKeysEnabledInFullScreen; }
+    Element* webkitCurrentFullScreenElement() const { return m_fullScreenElement.get(); }
+    void webkitRequestFullScreenForElement(Element*, unsigned short flags);
+    void webkitCancelFullScreen();
+    
+    void webkitWillEnterFullScreenForElement(Element*);
+    void webkitDidEnterFullScreenForElement(Element*);
+    void webkitWillExitFullScreenForElement(Element*);
+    void webkitDidExitFullScreenForElement(Element*);
+#endif
 
     bool writeDisabled() const { return m_writeDisabled; }
     void setWriteDisabled(bool flag) { m_writeDisabled = flag; }
@@ -1284,6 +1300,12 @@ private:
     HashSet<MediaCanStartListener*> m_mediaCanStartListeners;
 
     QualifiedName m_idAttributeName;
+    
+#if ENABLE(FULLSCREEN_API)
+    bool m_isFullScreen;
+    bool m_areKeysEnabledInFullScreen;
+    RefPtr<Element> m_fullScreenElement;
+#endif
 
     int m_loadEventDelayCount;
 };
index 3ae551e..0bd93b8 100644 (file)
@@ -245,6 +245,13 @@ module core {
         [DontEnum] void initializeWMLPageState();
 #endif
 
+#if defined(ENABLE_FULLSCREEN_API) && ENABLE_FULLSCREEN_API
+        readonly attribute boolean webkitFullScreen;
+        readonly attribute boolean webkitFullScreenKeyboardInputAllowed;
+        readonly attribute Element webkitCurrentFullScreenElement;
+        void webkitCancelFullScreen();
+#endif
+
 #if !defined(LANGUAGE_OBJECTIVE_C) || !LANGUAGE_OBJECTIVE_C
         // Event handler DOM attributes
         attribute [DontEnum] EventListener onabort;
@@ -317,6 +324,7 @@ module core {
         attribute [DontEnum,Conditional=TOUCH_EVENTS,EnabledAtRuntime] EventListener ontouchmove;
         attribute [DontEnum,Conditional=TOUCH_EVENTS,EnabledAtRuntime] EventListener ontouchend;
         attribute [DontEnum,Conditional=TOUCH_EVENTS,EnabledAtRuntime] EventListener ontouchcancel;
+        attribute [DontEnum, Conditional=FULLSCREEN_API] EventListener onwebkitfullscreenchange;
 #endif
 
 #if defined(LANGUAGE_CPP) && LANGUAGE_CPP
index abe3da3..7502864 100644 (file)
@@ -1591,5 +1591,12 @@ bool Element::childShouldCreateRenderer(Node* child) const
     return Node::childShouldCreateRenderer(child);
 }
 #endif
+    
+#if ENABLE(FULLSCREEN_API)
+void Element::webkitRequestFullScreen(unsigned short flags)
+{
+    document()->webkitRequestFullScreenForElement(this, flags);
+}
+#endif    
 
 } // namespace WebCore
index 694db98..570ee0a 100644 (file)
@@ -94,6 +94,9 @@ public:
     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchend);
     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchcancel);
 #endif
+#if ENABLE(FULLSCREEN_API)
+    DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitfullscreenchange);
+#endif
 
     virtual PassRefPtr<DocumentFragment> deprecatedCreateContextualFragment(const String&, FragmentScriptingPermission = FragmentScriptingAllowed);
 
@@ -292,6 +295,14 @@ public:
 #if ENABLE(SVG)
     virtual bool childShouldCreateRenderer(Node*) const; 
 #endif
+    
+#if ENABLE(FULLSCREEN_API)
+    enum {
+        ALLOW_KEYBOARD_INPUT = 1
+    };
+    
+    void webkitRequestFullScreen(unsigned short flags);
+#endif
 
 protected:
     Element(const QualifiedName& tagName, Document* document, ConstructionType type)
index 0ad3184..0141313 100644 (file)
@@ -133,6 +133,11 @@ module core {
         readonly attribute DOMString innerText;
 #endif
 
+#if defined(ENABLE_FULLSCREEN_API) && ENABLE_FULLSCREEN_API
+        const unsigned short ALLOW_KEYBOARD_INPUT = 1;
+        void webkitRequestFullScreen(in unsigned short flags);
+#endif
+
 #if !defined(LANGUAGE_OBJECTIVE_C) || !LANGUAGE_OBJECTIVE_C
         // Event handler DOM attributes
         attribute [DontEnum] EventListener onabort;
@@ -205,6 +210,7 @@ module core {
         attribute [DontEnum,Conditional=TOUCH_EVENTS,EnabledAtRuntime] EventListener ontouchmove;
         attribute [DontEnum,Conditional=TOUCH_EVENTS,EnabledAtRuntime] EventListener ontouchend;
         attribute [DontEnum,Conditional=TOUCH_EVENTS,EnabledAtRuntime] EventListener ontouchcancel;
+        attribute [DontEnum, Conditional=FULLSCREEN_API] EventListener onwebkitfullscreenchange;
 #endif
     };
 
index ebed2e1..e50ade0 100644 (file)
@@ -166,6 +166,8 @@ namespace WebCore {
     \
     macro(loadend) \
     \
+    macro(webkitfullscreenchange)
+    \
 // end of DOM_EVENT_NAMES_FOR_EACH
 
     class EventNames : public Noncopyable {
index b4cdb02..103d2c6 100644 (file)
@@ -223,6 +223,7 @@ onwebkitanimationiteration
 onwebkitanimationend
 onwebkitbeginfullscreen
 onwebkitendfullscreen
+onwebkitfullscreenchange
 onwebkittransitionend
 optimum
 pattern
index f40489b..0862130 100644 (file)
@@ -249,6 +249,10 @@ void HTMLElement::parseMappedAttribute(Attribute* attr)
         setAttributeEventListener(eventNames().touchendEvent, createAttributeEventListener(this, attr));
     } else if (attr->name() == ontouchcancelAttr) {
         setAttributeEventListener(eventNames().touchcancelEvent, createAttributeEventListener(this, attr));
+#if ENABLE(FULLSCREEN_API)
+    } else if (attr->name() == onwebkitfullscreenchangeAttr) {
+        setAttributeEventListener(eventNames().webkitfullscreenchangeEvent, createAttributeEventListener(this, attr));
+#endif
     }
 }
 
index 60b73c3..d3e1662 100644 (file)
@@ -234,6 +234,12 @@ namespace WebCore {
         virtual void enterFullscreenForNode(Node*) { }
         virtual void exitFullscreenForNode(Node*) { }
 
+#if ENABLE(FULLSCREEN_API)
+        virtual bool supportsFullScreenForElement(const Element*) { return false; }
+        virtual void enterFullScreenForElement(Element*) { }
+        virtual void exitFullScreenForElement(Element*) { }
+#endif
+        
 #if ENABLE(TILED_BACKING_STORE)
         virtual IntRect visibleRectForTiledBackingStore() const { return IntRect(); }
 #endif
index 866b45a..10e6f3e 100644 (file)
@@ -134,6 +134,9 @@ Settings::Settings(Page* page)
     , m_tiledBackingStoreEnabled(false)
     , m_paginateDuringLayoutEnabled(false)
     , m_dnsPrefetchingEnabled(true)
+#if ENABLE(FULLSCREEN_API)
+    , m_fullScreenAPIEnabled(false)
+#endif
     , m_memoryInfoEnabled(false)
     , m_interactiveFormValidation(false)
 {
index 7c6b8c9..693cc54 100644 (file)
@@ -311,6 +311,11 @@ namespace WebCore {
         void setPaginateDuringLayoutEnabled(bool flag) { m_paginateDuringLayoutEnabled = flag; }
         bool paginateDuringLayoutEnabled() const { return m_paginateDuringLayoutEnabled; }
 
+#if ENABLE(FULLSCREEN_API)
+        void setFullScreenEnabled(bool flag) { m_fullScreenAPIEnabled = flag; }
+        bool fullScreenEnabled() const  { return m_fullScreenAPIEnabled; }
+#endif
+
         void setMemoryInfoEnabled(bool flag) { m_memoryInfoEnabled = flag; }
         bool memoryInfoEnabled() const { return m_memoryInfoEnabled; }
 
@@ -402,6 +407,9 @@ namespace WebCore {
         bool m_tiledBackingStoreEnabled : 1;
         bool m_paginateDuringLayoutEnabled : 1;
         bool m_dnsPrefetchingEnabled : 1;
+#if ENABLE(FULLSCREEN_API)
+        bool m_fullScreenAPIEnabled : 1;
+#endif
         bool m_memoryInfoEnabled: 1;
         bool m_interactiveFormValidation: 1;
     
index d82aa73..3567004 100644 (file)
@@ -51,7 +51,7 @@ enum ControlPart {
     MediaFullscreenButtonPart, MediaMuteButtonPart, MediaPlayButtonPart, MediaSeekBackButtonPart, 
     MediaSeekForwardButtonPart, MediaRewindButtonPart, MediaReturnToRealtimeButtonPart, MediaToggleClosedCaptionsButtonPart,
     MediaSliderPart, MediaSliderThumbPart, MediaVolumeSliderContainerPart, MediaVolumeSliderPart, MediaVolumeSliderThumbPart,
-    MediaVolumeSliderMuteButtonPart, MediaControlsBackgroundPart, MediaCurrentTimePart, MediaTimeRemainingPart,
+    MediaVolumeSliderMuteButtonPart, MediaControlsBackgroundPart, MediaControlsFullscreenBackgroundPart, MediaCurrentTimePart, MediaTimeRemainingPart,
     MenulistPart, MenulistButtonPart, MenulistTextPart, MenulistTextFieldPart, MeterPart, OuterSpinButtonPart, ProgressBarPart, ProgressBarValuePart,
     SliderHorizontalPart, SliderVerticalPart, SliderThumbHorizontalPart,
     SliderThumbVerticalPart, CaretPart, SearchFieldPart, SearchFieldDecorationPart,
index 3fb712f..aaeb3e2 100644 (file)
@@ -42,6 +42,7 @@
 #include "RenderMedia.h"
 #include "RenderSlider.h"
 #include "RenderTheme.h"
+#include "Settings.h"
 
 namespace WebCore {
 
@@ -780,7 +781,20 @@ PassRefPtr<MediaControlFullscreenButtonElement> MediaControlFullscreenButtonElem
 void MediaControlFullscreenButtonElement::defaultEventHandler(Event* event)
 {
     if (event->type() == eventNames().clickEvent) {
-        mediaElement()->enterFullscreen();
+#if ENABLE(FULLSCREEN_API)
+        // Only use the new full screen API if the fullScreenEnabled setting has 
+        // been explicitly enabled.  Otherwise, use the old fullscreen API.  This
+        // allows apps which embed a WebView to retain the existing full screen
+        // video implementation without requiring them to implement their own full 
+        // screen behavior.
+        if (document()->settings() && document()->settings()->fullScreenEnabled()) {
+            if (document()->webkitFullScreen() && document()->webkitCurrentFullScreenElement() == mediaElement())
+                document()->webkitCancelFullScreen();
+            else
+                mediaElement()->webkitRequestFullScreen(0);
+        } else
+#endif
+            mediaElement()->enterFullscreen();
         event->setDefaultHandled();
     }
     HTMLInputElement::defaultEventHandler(event);
index 70b128b..286357d 100644 (file)
@@ -79,6 +79,7 @@ enum PseudoId {
     METER_HORIZONTAL_BAR, METER_HORIZONTAL_OPTIMUM, METER_HORIZONTAL_SUBOPTIMAL, METER_HORIZONTAL_EVEN_LESS_GOOD,
     METER_VERTICAL_BAR, METER_VERTICAL_OPTIMUM, METER_VERTICAL_SUBOPTIMAL, METER_VERTICAL_EVEN_LESS_GOOD, 
     AFTER_LAST_INTERNAL_PSEUDOID,
+    FULL_SCREEN, FULL_SCREEN_DOCUMENT,
     FIRST_PUBLIC_PSEUDOID = FIRST_LINE,
     FIRST_INTERNAL_PSEUDOID = FILE_UPLOAD_BUTTON,
     PUBLIC_PSEUDOID_MASK = ((1 << FIRST_INTERNAL_PSEUDOID) - 1) & ~((1 << FIRST_PUBLIC_PSEUDOID) - 1)
index 56f96b5..f53227d 100644 (file)
@@ -1,3 +1,36 @@
+2010-07-27  Jer Noble  <jer.noble@apple.com>
+
+        Reviewed by Eric Carlson.
+
+        Add JavaScript API to allow a page to go fullscreen.
+        rdar://problem/6867795
+
+        Added chrome client overrides which support entering and exiting full screen.  A new preference has
+        been added (setFullScreenEnabled:) to control at runtime whether full screen support is enabled 
+        (defaults to disabled).  Added a new WebKitFullScreenListener callback object which notifies WebCore
+        when the chrome has started/finished its full screen animation.
+
+        * Configurations/FeatureDefines.xcconfig:
+        * WebCoreSupport/WebChromeClient.h:
+        * WebCoreSupport/WebChromeClient.mm:
+        (WebChromeClient::supportsFullscreenForElement):
+        (WebChromeClient::enterFullscreenForElement):
+        (WebChromeClient::exitFullscreenForElement):
+        (-[WebKitFullScreenListener initWithElement:]):
+        (-[WebKitFullScreenListener webkitWillEnterFullScreen]):
+        (-[WebKitFullScreenListener webkitDidEnterFullScreen]):
+        (-[WebKitFullScreenListener webkitWillExitFullScreen]):
+        (-[WebKitFullScreenListener webkitDidExitFullScreen]):
+        * WebView/WebPreferenceKeysPrivate.h:
+        * WebView/WebPreferences.h:
+        * WebView/WebPreferences.mm:
+        (+[WebPreferences initialize]):
+        (-[WebPreferences setFullScreenEnabled:]):
+        (-[WebPreferences fullScreenEnabled]):
+        * WebView/WebUIDelegatePrivate.h:
+        * WebView/WebView.mm:
+        (-[WebView _preferencesChangedNotification:]):
+
 2010-08-27  David Hyatt  <hyatt@apple.com>
 
         Reviewed by Simon Fraser.
index f2b4c09..8f8c213 100644 (file)
@@ -71,6 +71,7 @@ ENABLE_FILTERS_macosx = ENABLE_FILTERS;
 
 ENABLE_FILE_WRITER = ;
 ENABLE_FILE_SYSTEM = ;
+ENABLE_FULLSCREEN_API = ENABLE_FULLSCREEN_API;
 ENABLE_GEOLOCATION = ENABLE_GEOLOCATION;
 
 ENABLE_ICONDATABASE = $(ENABLE_ICONDATABASE_$(REAL_PLATFORM_NAME));
@@ -120,4 +121,4 @@ ENABLE_XHTMLMP = ;
 ENABLE_XPATH = ENABLE_XPATH;
 ENABLE_XSLT = ENABLE_XSLT;
 
-FEATURE_DEFINES = $(ENABLE_LINK_PREFETCH) $(ENABLE_3D_CANVAS) $(ENABLE_3D_RENDERING) $(ENABLE_BLOB) $(ENABLE_CHANNEL_MESSAGING) $(ENABLE_CLIENT_BASED_GEOLOCATION) $(ENABLE_DATABASE) $(ENABLE_DATAGRID) $(ENABLE_DATALIST) $(ENABLE_DEVICE_ORIENTATION) $(ENABLE_DIRECTORY_UPLOAD) $(ENABLE_DOM_STORAGE) $(ENABLE_EVENTSOURCE) $(ENABLE_FILTERS) $(ENABLE_FILE_WRITER) $(ENABLE_FILE_SYSTEM) $(ENABLE_GEOLOCATION) $(ENABLE_ICONDATABASE) $(ENABLE_IMAGE_RESIZER) $(ENABLE_INDEXED_DATABASE) $(ENABLE_INPUT_SPEECH) $(ENABLE_JAVASCRIPT_DEBUGGER) $(ENABLE_MATHML) $(ENABLE_METER_TAG) $(ENABLE_NOTIFICATIONS) $(ENABLE_OFFLINE_WEB_APPLICATIONS) $(ENABLE_PROGRESS_TAG) $(ENABLE_RUBY) $(ENABLE_SANDBOX) $(ENABLE_SHARED_WORKERS) $(ENABLE_SVG) $(ENABLE_SVG_ANIMATION) $(ENABLE_SVG_AS_IMAGE) $(ENABLE_SVG_DOM_OBJC_BINDINGS) $(ENABLE_SVG_FONTS) $(ENABLE_SVG_FOREIGN_OBJECT) $(ENABLE_SVG_USE) $(ENABLE_VIDEO) $(ENABLE_WEB_SOCKETS) $(ENABLE_WEB_TIMING) $(ENABLE_WML) $(ENABLE_WORKERS) $(ENABLE_XHTMLMP) $(ENABLE_XPATH) $(ENABLE_XSLT);
+FEATURE_DEFINES = $(ENABLE_LINK_PREFETCH) $(ENABLE_3D_CANVAS) $(ENABLE_3D_RENDERING) $(ENABLE_BLOB) $(ENABLE_CHANNEL_MESSAGING) $(ENABLE_CLIENT_BASED_GEOLOCATION) $(ENABLE_DATABASE) $(ENABLE_DATAGRID) $(ENABLE_DATALIST) $(ENABLE_DEVICE_ORIENTATION) $(ENABLE_DIRECTORY_UPLOAD) $(ENABLE_DOM_STORAGE) $(ENABLE_EVENTSOURCE) $(ENABLE_FILTERS) $(ENABLE_FILE_WRITER) $(ENABLE_FILE_SYSTEM) $(ENABLE_FULLSCREEN_API) $(ENABLE_GEOLOCATION) $(ENABLE_ICONDATABASE) $(ENABLE_IMAGE_RESIZER) $(ENABLE_INDEXED_DATABASE) $(ENABLE_INPUT_SPEECH) $(ENABLE_JAVASCRIPT_DEBUGGER) $(ENABLE_MATHML) $(ENABLE_METER_TAG) $(ENABLE_NOTIFICATIONS) $(ENABLE_OFFLINE_WEB_APPLICATIONS) $(ENABLE_PROGRESS_TAG) $(ENABLE_RUBY) $(ENABLE_SANDBOX) $(ENABLE_SHARED_WORKERS) $(ENABLE_SVG) $(ENABLE_SVG_ANIMATION) $(ENABLE_SVG_AS_IMAGE) $(ENABLE_SVG_DOM_OBJC_BINDINGS) $(ENABLE_SVG_FONTS) $(ENABLE_SVG_FOREIGN_OBJECT) $(ENABLE_SVG_USE) $(ENABLE_VIDEO) $(ENABLE_WEB_SOCKETS) $(ENABLE_WEB_TIMING) $(ENABLE_WML) $(ENABLE_WORKERS) $(ENABLE_XHTMLMP) $(ENABLE_XPATH) $(ENABLE_XSLT);
index e5de14d..5f3b727 100644 (file)
@@ -164,6 +164,12 @@ public:
     virtual void enterFullscreenForNode(WebCore::Node*);
     virtual void exitFullscreenForNode(WebCore::Node*);
 #endif
+    
+#if ENABLE(FULLSCREEN_API)
+    virtual bool supportsFullScreenForElement(const WebCore::Element*);
+    virtual void enterFullScreenForElement(WebCore::Element*);
+    virtual void exitFullScreenForElement(WebCore::Element*);
+#endif
 
     virtual void requestGeolocationPermissionForFrame(WebCore::Frame*, WebCore::Geolocation*);
     virtual void cancelGeolocationPermissionRequestForFrame(WebCore::Frame*, WebCore::Geolocation*) { }
index 2c2616d..d973e2b 100644 (file)
@@ -110,6 +110,16 @@ using namespace WebCore;
 - (id)initWithGeolocation:(Geolocation*)geolocation;
 @end
 
+#if ENABLE(FULLSCREEN_API)
+@interface WebKitFullScreenListener : NSObject <WebKitFullScreenListener>
+{
+    RefPtr<Element> _element;
+}
+
+- (id)initWithElement:(Element*)element;
+@end
+#endif
+
 WebChromeClient::WebChromeClient(WebView *webView) 
     : m_webView(webView)
 {
@@ -815,6 +825,29 @@ void WebChromeClient::exitFullscreenForNode(Node*)
 
 #endif
 
+#if ENABLE(FULLSCREEN_API)
+
+bool WebChromeClient::supportsFullScreenForElement(const Element* element)
+{
+    return CallUIDelegateReturningBoolean(false, m_webView, @selector(webView:supportsFullScreenForElement:), kit(const_cast<WebCore::Element*>(element)));
+}
+
+void WebChromeClient::enterFullScreenForElement(Element* element)
+{
+    WebKitFullScreenListener* listener = [[WebKitFullScreenListener alloc] initWithElement:element];
+    CallUIDelegate(m_webView, @selector(webView:enterFullScreenForElement:listener:), kit(element), listener);
+    [listener release];
+}
+
+void WebChromeClient::exitFullScreenForElement(Element* element)
+{
+    WebKitFullScreenListener* listener = [[WebKitFullScreenListener alloc] initWithElement:element];
+    CallUIDelegate(m_webView, @selector(webView:exitFullScreenForElement:listener:), kit(element), listener);
+    [listener release];
+}
+
+#endif
+
 void WebChromeClient::requestGeolocationPermissionForFrame(Frame* frame, Geolocation* geolocation)
 {
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
@@ -919,3 +952,41 @@ void WebChromeClient::requestGeolocationPermissionForFrame(Frame* frame, Geoloca
 }
 
 @end
+
+#if ENABLE(FULLSCREEN_API)
+@implementation WebKitFullScreenListener
+- (id)initWithElement:(Element*)element
+{
+    if (!(self = [super init]))
+        return nil;
+    
+    _element = element;
+    return self;
+}
+
+- (void)webkitWillEnterFullScreen
+{
+    if (_element)
+        _element->document()->webkitWillEnterFullScreenForElement(_element.get());
+}
+
+- (void)webkitDidEnterFullScreen
+{
+    if (_element)
+        _element->document()->webkitDidEnterFullScreenForElement(_element.get());
+}
+
+- (void)webkitWillExitFullScreen
+{
+    if (_element)
+        _element->document()->webkitWillExitFullScreenForElement(_element.get());
+}
+
+- (void)webkitDidExitFullScreen
+{
+    if (_element)
+        _element->document()->webkitDidExitFullScreenForElement(_element.get());
+}
+
+@end
+#endif
index 86f6d85..3b750ff 100644 (file)
@@ -97,6 +97,7 @@
 #define WebKitFrameFlatteningEnabledPreferenceKey @"WebKitFrameFlatteningEnabled"
 #define WebKitPaginateDuringLayoutEnabledPreferenceKey @"WebKitPaginateDuringLayoutEnabled"
 #define WebKitDNSPrefetchingEnabledPreferenceKey @"WebKitDNSPrefetchingEnabled"
+#define WebKitFullScreenEnabledPreferenceKey @"WebKitFullScreenEnabled"
 #define WebKitMemoryInfoEnabledPreferenceKey @"WebKitMemoryInfoEnabled"
 
 // These are private both because callers should be using the cover methods and because the
index eae2d8d..a4a5383 100644 (file)
@@ -365,6 +365,7 @@ static WebCacheModel cacheModelForMainBundle(void)
         [NSNumber numberWithUnsignedInt:4], WebKitPluginAllowedRunTimePreferenceKey,
         [NSNumber numberWithBool:NO],   WebKitFrameFlatteningEnabledPreferenceKey,
         [NSNumber numberWithBool:YES],  WebKitDNSPrefetchingEnabledPreferenceKey,
+        [NSNumber numberWithBool:NO],   WebKitFullScreenEnabledPreferenceKey,
         [NSNumber numberWithBool:NO],   WebKitMemoryInfoEnabledPreferenceKey,
         [NSNumber numberWithLongLong:WebCore::ApplicationCacheStorage::noQuota()], WebKitApplicationCacheTotalQuota,
         [NSNumber numberWithLongLong:WebCore::ApplicationCacheStorage::noQuota()], WebKitApplicationCacheDefaultOriginQuota,
@@ -1346,6 +1347,16 @@ static NSString *classIBCreatorID = nil;
     [self _setStringValue:value forKey:key];
 }
 
+- (void)setFullScreenEnabled:(BOOL)flag
+{
+    [self _setBoolValue:flag forKey:WebKitFullScreenEnabledPreferenceKey];
+}
+
+- (BOOL)fullScreenEnabled
+{
+    return [self _boolValueForKey:WebKitFullScreenEnabledPreferenceKey];
+}
+
 @end
 
 @implementation WebPreferences (WebInternal)
index 45c2a24..783038d 100644 (file)
@@ -206,4 +206,10 @@ extern NSString *WebPreferencesRemovedNotification;
 // For WebView's use only.
 - (void)willAddToWebView;
 - (void)didRemoveFromWebView;
+
+// Full screen support is dependent on WebCore/WebKit being
+// compiled with ENABLE_FULLSCREEN_API. 
+- (void)setFullScreenEnabled:(BOOL)flag;
+- (BOOL)fullScreenEnabled;
+
 @end
index 0fb120c..22752ae 100644 (file)
@@ -95,6 +95,15 @@ enum {
 - (void)deny;
 @end
 
+#if ENABLE(FULLSCREEN_API)
+@protocol WebKitFullScreenListener<NSObject>
+- (void)webkitWillEnterFullScreen;
+- (void)webkitDidEnterFullScreen;
+- (void)webkitWillExitFullScreen;
+- (void)webkitDidExitFullScreen;
+@end
+#endif
+
 @interface NSObject (WebUIDelegatePrivate)
 
 - (void)webView:(WebView *)webView addMessageToConsole:(NSDictionary *)message;
@@ -164,4 +173,10 @@ enum {
 */
 - (void)webView:(WebView *)sender printFrame:(WebFrame *)frame;
 
+#if ENABLE(FULLSCREEN_API)
+- (BOOL)webView:(WebView *)sender supportsFullScreenForElement:(DOMElement *)element;
+- (void)webView:(WebView *)sender enterFullScreenForElement:(DOMElement *)element;
+- (void)webView:(WebView *)sender exitFullScreenForElement:(DOMElement *)element;
+#endif
+
 @end
index 322dd45..a8c405c 100644 (file)
@@ -1438,6 +1438,9 @@ static bool fastDocumentTeardownEnabled()
     settings->setLoadDeferringEnabled(shouldEnableLoadDeferring());
     settings->setFrameFlatteningEnabled([preferences isFrameFlatteningEnabled]);
     settings->setPaginateDuringLayoutEnabled([preferences paginateDuringLayoutEnabled]);
+#if ENABLE(FULLSCREEN_API)
+    settings->setFullScreenEnabled([preferences fullScreenEnabled]);
+#endif
     settings->setMemoryInfoEnabled([preferences memoryInfoEnabled]);
 
     // Application Cache Preferences are stored on the global cache storage manager, not in Settings.
index dad41a7..c0b9002 100644 (file)
@@ -1,3 +1,22 @@
+2010-07-27  Jer Noble  <jer.noble@apple.com>
+
+        Reviewed by Eric Carlson.
+
+        Add JavaScript API to allow a page to go fullscreen.
+        rdar://problem/6867795
+        
+        Added basic full screen support to DumpRenderTree: when a webView requests
+        that DumpRenderTree go "full screen", just call the provided callback listener object's
+        will/did Enter/Exit full screen methods.  Also, register a new user default which 
+        enables full screen support.
+
+        * DumpRenderTree/mac/DumpRenderTree.mm:
+        (resetDefaultsToConsistentValues):
+        * DumpRenderTree/mac/UIDelegate.mm:
+        (-[UIDelegate webView:supportsFullscreenForElement:]):
+        (-[UIDelegate webView:enterFullscreenForElement:listener:]):
+        (-[UIDelegate webView:exitFullscreenForElement:listener:]):
+
 2010-08-27  Benjamin Poulain  <benjamin.poulain@nokia.com>
 
         Unreviewed. Add myself to the committers list.
index 12a4a50..e756ebf 100644 (file)
@@ -389,6 +389,7 @@ static void resetDefaultsToConsistentValues()
     [defaults setObject:@"0.500000 0.500000 0.500000" forKey:@"AppleOtherHighlightColor"];
     [defaults setObject:[NSArray arrayWithObject:@"en"] forKey:@"AppleLanguages"];
     [defaults setBool:YES forKey:WebKitEnableFullDocumentTeardownPreferenceKey];
+    [defaults setBool:YES forKey:WebKitFullScreenEnabledPreferenceKey];
 
     // Scrollbars are drawn either using AppKit (which uses NSUserDefaults) or using HIToolbox (which uses CFPreferences / kCFPreferencesAnyApplication / kCFPreferencesCurrentUser / kCFPreferencesAnyHost)
     [defaults setObject:@"DoubleMax" forKey:@"AppleScrollBarVariant"];
index f9afdb1..6194c26 100644 (file)
@@ -227,6 +227,23 @@ DumpRenderTreeDraggingInfo *draggingInfo = nil;
     return NO;
 }
 
+- (BOOL)webView:(WebView *)webView supportsFullScreenForElement:(DOMElement*)element
+{
+    return YES;
+}
+
+- (void)webView:(WebView *)webView enterFullScreenForElement:(DOMElement*)element listener:(NSObject<WebKitFullScreenListener>*)listener
+{
+    [listener webkitWillEnterFullScreen];
+    [listener webkitDidEnterFullScreen];
+}
+
+- (void)webView:(WebView *)webView exitFullScreenForElement:(DOMElement*)element listener:(NSObject<WebKitFullScreenListener>*)listener
+{
+    [listener webkitWillExitFullScreen];
+    [listener webkitDidExitFullScreen];
+}
+
 - (BOOL)webView:(WebView *)webView didPressMissingPluginButton:(DOMElement *)element
 {
     printf("MISSING PLUGIN BUTTON PRESSED\n");