/*

 * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.

 * Copyright (C) 2007 Trolltech ASA

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1.  Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer. 

 * 2.  Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution. 

 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission. 

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#import "WebChromeClient.h"

#import "WebDefaultUIDelegate.h"

#import "WebElementDictionary.h"

#import "WebFrameInternal.h"

#import "WebFrameView.h"

#import "WebHTMLView.h"

#import "WebHTMLViewPrivate.h"

#import "WebNSURLRequestExtras.h"

#import "WebUIDelegate.h"

#import "WebUIDelegatePrivate.h"

#import "WebView.h"

#import "WebViewInternal.h"

#import <WebCore/BlockExceptions.h>

#import <WebCore/FloatRect.h>

#import <WebCore/FrameLoadRequest.h>

#import <WebCore/HitTestResult.h>

#import <WebCore/IntRect.h>

#import <WebCore/PlatformScreen.h>

#import <WebCore/PlatformString.h>

#import <WebCore/ResourceRequest.h>

#import <wtf/PassRefPtr.h>

@interface NSView (AppKitSecretsWebBridgeKnowsAbout)

- (NSView *)_findLastViewInKeyViewLoop;

@end

using namespace WebCore;

WebChromeClient::WebChromeClient(WebView *webView) 

    : m_webView(webView)

{

}

void WebChromeClient::chromeDestroyed()

{

    delete this;

}

// These functions scale between window and WebView coordinates because JavaScript/DOM operations 

// assume that the WebView and the window share the same coordinate system.

void WebChromeClient::setWindowRect(const FloatRect& rect)

{

    NSRect windowRect = toDeviceSpace(rect, [m_webView window]);

    [[m_webView _UIDelegateForwarder] webView:m_webView setFrame:windowRect];

}

FloatRect WebChromeClient::windowRect()

{

    NSRect windowRect = [[m_webView _UIDelegateForwarder] webViewFrame:m_webView];

    return toUserSpace(windowRect, [m_webView window]);

}

// FIXME: We need to add API for setting and getting this.

FloatRect WebChromeClient::pageRect()

{

    return [m_webView frame];

}

float WebChromeClient::scaleFactor()

{

    if (NSWindow *window = [m_webView window])

        return [window  userSpaceScaleFactor];

    return [[NSScreen mainScreen] userSpaceScaleFactor];

}

void WebChromeClient::focus()

{

    [[m_webView _UIDelegateForwarder] webViewFocus:m_webView];

}

void WebChromeClient::unfocus()

{

    [[m_webView _UIDelegateForwarder] webViewUnfocus:m_webView];

}

bool WebChromeClient::canTakeFocus(FocusDirection)

{

    // There's unfortunately no way to determine if we will become first responder again

    // once we give it up, so we just have to guess that we won't.

    return true;

}

void WebChromeClient::takeFocus(FocusDirection direction)

{

    if (direction == FocusDirectionForward) {

        // Since we're trying to move focus out of m_webView, and because

        // m_webView may contain subviews within it, we ask it for the next key

        // view of the last view in its key view loop. This makes m_webView

        // behave as if it had no subviews, which is the behavior we want.

        NSView *lastView = [m_webView _findLastViewInKeyViewLoop];

        // avoid triggering assertions if the WebView is the only thing in the key loop

        if ([m_webView _becomingFirstResponderFromOutside] && m_webView == [lastView nextValidKeyView])

            return;

        [[m_webView window] selectKeyViewFollowingView:lastView];

    } else {

        // avoid triggering assertions if the WebView is the only thing in the key loop

        if ([m_webView _becomingFirstResponderFromOutside] && m_webView == [m_webView previousValidKeyView])

            return;

        [[m_webView window] selectKeyViewPrecedingView:m_webView];

    }

}

Page* WebChromeClient::createWindow(Frame*, const FrameLoadRequest& request)

{

    NSURLRequest *URLRequest = nil;

    if (!request.isEmpty())

        URLRequest = request.resourceRequest().nsURLRequest();

    WebView *newWebView = CallUIDelegate(m_webView, @selector(webView:createWebViewWithRequest:), URLRequest);

    return core(newWebView);

}

Page* WebChromeClient::createModalDialog(Frame*, const FrameLoadRequest& request)

{

    NSURLRequest *URLRequest = nil;

    if (!request.isEmpty())

        URLRequest = request.resourceRequest().nsURLRequest();

    WebView *newWebView = nil;

    id delegate = [m_webView UIDelegate];

    if ([delegate respondsToSelector:@selector(webView:createWebViewModalDialogWithRequest:)])

        newWebView = CallUIDelegate(m_webView, @selector(webView:createWebViewModalDialogWithRequest:), URLRequest);

    else if ([delegate respondsToSelector:@selector(webView:createWebViewWithRequest:)])

        newWebView = CallUIDelegate(m_webView, @selector(webView:createWebViewWithRequest:), URLRequest);

    return core(newWebView);

}

void WebChromeClient::show()

{

    [[m_webView _UIDelegateForwarder] webViewShow:m_webView];

}

bool WebChromeClient::canRunModal()

{

    return [[m_webView UIDelegate] respondsToSelector:@selector(webViewRunModal:)];

}

void WebChromeClient::runModal()

{

    CallUIDelegate(m_webView, @selector(webViewRunModal:));

}

void WebChromeClient::setToolbarsVisible(bool b)

{

    [[m_webView _UIDelegateForwarder] webView:m_webView setToolbarsVisible:b];

}

bool WebChromeClient::toolbarsVisible()

{

    return CallUIDelegateReturningBoolean(NO, m_webView, @selector(webViewAreToolbarsVisible:));

}

void WebChromeClient::setStatusbarVisible(bool b)

{

    [[m_webView _UIDelegateForwarder] webView:m_webView setStatusBarVisible:b];

}

bool WebChromeClient::statusbarVisible()

{

    return CallUIDelegateReturningBoolean(NO, m_webView, @selector(webViewIsStatusBarVisible:));

}

void WebChromeClient::setScrollbarsVisible(bool b)

{

    [[[m_webView mainFrame] frameView] setAllowsScrolling:b];

}

bool WebChromeClient::scrollbarsVisible()

{

    return [[[m_webView mainFrame] frameView] allowsScrolling];

}

void WebChromeClient::setMenubarVisible(bool)

{

    // The menubar is always visible in Mac OS X.

    return;

}

bool WebChromeClient::menubarVisible()

{

    // The menubar is always visible in Mac OS X.

    return true;

}

void WebChromeClient::setResizable(bool b)

{

    [[m_webView _UIDelegateForwarder] webView:m_webView setResizable:b];

}

void WebChromeClient::addMessageToConsole(const String& message, unsigned int lineNumber, const String& sourceURL)

{

    id delegate = [m_webView UIDelegate];

    SEL selector = @selector(webView:addMessageToConsole:);

    if (![delegate respondsToSelector:selector])

        return;

    NSDictionary *dictionary = [[NSDictionary alloc] initWithObjectsAndKeys:

        (NSString *)message, @"message", [NSNumber numberWithUnsignedInt:lineNumber], @"lineNumber",

        (NSString *)sourceURL, @"sourceURL", NULL];

    CallUIDelegate(m_webView, selector, dictionary);

    [dictionary release];

}

bool WebChromeClient::canRunBeforeUnloadConfirmPanel()

{

    return [[m_webView UIDelegate] respondsToSelector:@selector(webView:runBeforeUnloadConfirmPanelWithMessage:initiatedByFrame:)];

}

bool WebChromeClient::runBeforeUnloadConfirmPanel(const String& message, Frame* frame)

{

    return CallUIDelegateReturningBoolean(true, m_webView, @selector(webView:runBeforeUnloadConfirmPanelWithMessage:initiatedByFrame:), message, kit(frame));

}

void WebChromeClient::closeWindowSoon()

{

    // We need to remove the parent WebView from WebViewSets here, before it actually

    // closes, to make sure that JavaScript code that executes before it closes

    // can't find it. Otherwise, window.open will select a closed WebView instead of 

    // opening a new one <rdar://problem/3572585>.

    // We also need to stop the load to prevent further parsing or JavaScript execution

    // after the window has torn down <rdar://problem/4161660>.

    // FIXME: This code assumes that the UI delegate will respond to a webViewClose

    // message by actually closing the WebView. Safari guarantees this behavior, but other apps might not.

    // This approach is an inherent limitation of not making a close execute immediately

    // after a call to window.close.

    [m_webView setGroupName:nil];

    [m_webView stopLoading:nil];

    [m_webView performSelector:@selector(_closeWindow) withObject:nil afterDelay:0.0];

}

void WebChromeClient::runJavaScriptAlert(Frame* frame, const String& message)

{

    id delegate = [m_webView UIDelegate];

    SEL selector = @selector(webView:runJavaScriptAlertPanelWithMessage:initiatedByFrame:);

    if ([delegate respondsToSelector:selector]) {

        CallUIDelegate(m_webView, selector, message, kit(frame));

        return;

    }

    // Call the old version of the delegate method if it is implemented.

    selector = @selector(webView:runJavaScriptAlertPanelWithMessage:);

    if ([delegate respondsToSelector:selector]) {

        CallUIDelegate(m_webView, selector, message);

        return;

    }

}

bool WebChromeClient::runJavaScriptConfirm(Frame* frame, const String& message)

{

    id delegate = [m_webView UIDelegate];

    SEL selector = @selector(webView:runJavaScriptConfirmPanelWithMessage:initiatedByFrame:);

    if ([delegate respondsToSelector:selector])

        return CallUIDelegateReturningBoolean(NO, m_webView, selector, message, kit(frame));

    // Call the old version of the delegate method if it is implemented.

    selector = @selector(webView:runJavaScriptConfirmPanelWithMessage:);

    if ([delegate respondsToSelector:selector])

        return CallUIDelegateReturningBoolean(NO, m_webView, selector, message);

    return NO;

}

bool WebChromeClient::runJavaScriptPrompt(Frame* frame, const String& prompt, const String& defaultText, String& result)

{

    id delegate = [m_webView UIDelegate];

    SEL selector = @selector(webView:runJavaScriptTextInputPanelWithPrompt:defaultText:initiatedByFrame:);

    if ([delegate respondsToSelector:selector]) {

        result = (NSString *)CallUIDelegate(m_webView, selector, prompt, defaultText, kit(frame));

        return !result.isNull();

    }

    // Call the old version of the delegate method if it is implemented.

    selector = @selector(webView:runJavaScriptTextInputPanelWithPrompt:defaultText:);

    if ([delegate respondsToSelector:selector]) {

        result = (NSString *)CallUIDelegate(m_webView, selector, prompt, defaultText);

        return !result.isNull();

    }

    result = [[WebDefaultUIDelegate sharedUIDelegate] webView:m_webView runJavaScriptTextInputPanelWithPrompt:prompt defaultText:defaultText initiatedByFrame:kit(frame)];

    return !result.isNull();

}

bool WebChromeClient::shouldInterruptJavaScript()

{

    return CallUIDelegate(m_webView, @selector(webViewShouldInterruptJavaScript:));

}

void WebChromeClient::setStatusbarText(const WebCore::String& status)

{

    // We want the temporaries allocated here to be released even before returning to the 

    // event loop; see <http://bugs.webkit.org/show_bug.cgi?id=9880>.

    NSAutoreleasePool* localPool = [[NSAutoreleasePool alloc] init];

    CallUIDelegate(m_webView, @selector(webView:setStatusText:), (NSString *)status);

    [localPool drain];

}

bool WebChromeClient::tabsToLinks() const

{

    return [[m_webView preferences] tabsToLinks];

}

IntRect WebChromeClient::windowResizerRect() const

{

    return IntRect();

}

void WebChromeClient::addToDirtyRegion(const IntRect&)

{

}

void WebChromeClient::scrollBackingStore(int, int, const IntRect&, const IntRect&)

{

}

void WebChromeClient::updateBackingStore()

{

}

void WebChromeClient::mouseDidMoveOverElement(const HitTestResult& result, unsigned modifierFlags)

{

    WebElementDictionary *element = [[WebElementDictionary alloc] initWithHitTestResult:result];

    [m_webView _mouseDidMoveOverElement:element modifierFlags:modifierFlags];

    [element release];

}

void WebChromeClient::setToolTip(const String& toolTip)

{

    [(WebHTMLView *)[[[m_webView mainFrame] frameView] documentView] _setToolTip:toolTip];

}

void WebChromeClient::print(Frame* frame)

{

    WebFrameView* frameView = [kit(frame) frameView];

    CallUIDelegate(m_webView, @selector(webView:printFrameView:), frameView);

}