/*

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

 *

 * 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 "WebFrameView.h"

#import "WebClipView.h"

#import "WebDataSourcePrivate.h"

#import "WebDocument.h"

#import "WebDynamicScrollBarsViewInternal.h"

#import "WebFrame.h"

#import "WebFrameInternal.h"

#import "WebFrameViewInternal.h"

#import "WebFrameViewPrivate.h"

#import "WebHistoryItemInternal.h"

#import "WebHTMLViewPrivate.h"

#import "WebKeyGenerator.h"

#import "WebKitErrorsPrivate.h"

#import "WebKitStatisticsPrivate.h"

#import "WebKitVersionChecks.h"

#import "WebNSDictionaryExtras.h"

#import "WebNSObjectExtras.h"

#import "WebNSPasteboardExtras.h"

#import "WebNSViewExtras.h"

#import "WebNSWindowExtras.h"

#import "WebPDFView.h"

#import "WebPreferenceKeysPrivate.h"

#import "WebResourceInternal.h"

#import "WebSystemInterface.h"

#import "WebViewFactory.h"

#import "WebViewInternal.h"

#import "WebViewPrivate.h"

#import <Foundation/NSURLRequest.h>

#import <WebCore/BackForwardList.h>

#import <WebCore/DragController.h>

#import <WebCore/EventHandler.h>

#import <WebCore/Frame.h>

#import <WebCore/FrameView.h>

#import <WebCore/HistoryItem.h>

#import <WebCore/Page.h>

#import <WebCore/RenderPart.h>

#import <WebCore/ThreadCheck.h>

#import <WebCore/WebCoreFrameView.h>

#import <WebCore/WebCoreView.h>

#import <WebKitSystemInterface.h>

#import <wtf/Assertions.h>

using namespace WebCore;

@interface NSWindow (WindowPrivate)

- (BOOL)_needsToResetDragMargins;

- (void)_setNeedsToResetDragMargins:(BOOL)s;

@end

@interface NSClipView (AppKitSecretsIKnow)

- (BOOL)_scrollTo:(const NSPoint *)newOrigin animate:(BOOL)animate; // need the boolean result from this method

@end

enum {

    SpaceKey = 0x0020

};

@interface WebFrameView (WebFrameViewFileInternal) <WebCoreFrameView>

- (float)_verticalKeyboardScrollDistance;

@end

@interface WebFrameViewPrivate : NSObject {

@public

    WebFrame *webFrame;

    WebDynamicScrollBarsView *frameScrollView;

    BOOL includedInWebKitStatistics;

}

@end

@implementation WebFrameViewPrivate

- (void)dealloc

{

    [frameScrollView release];

    [super dealloc];

}

@end

@implementation WebFrameView (WebFrameViewFileInternal)

- (float)_verticalKeyboardScrollDistance

{

    // Arrow keys scroll the same distance that clicking the scroll arrow does.

    return [[self _scrollView] verticalLineScroll];

}

- (Frame*)_web_frame

{

    return core(_private->webFrame);

}

@end

@implementation WebFrameView (WebInternal)

// Note that the WebVew is not retained.

- (WebView *)_webView

{

    return [_private->webFrame webView];

}

- (void)_setDocumentView:(NSView <WebDocumentView> *)view

{

    WebDynamicScrollBarsView *sv = [self _scrollView];

    core([self _webView])->dragController()->setDidInitiateDrag(false);

    [sv setSuppressLayout:YES];

    // If the old view is the first responder, transfer first responder status to the new view as 

    // a convenience and so that we don't leave the window pointing to a view that's no longer in it.

    NSWindow *window = [sv window];

    NSResponder *firstResponder = [window firstResponder];

    bool makeNewViewFirstResponder = [firstResponder isKindOfClass:[NSView class]] && [(NSView *)firstResponder isDescendantOf:[sv documentView]];

    // Suppress the resetting of drag margins since we know we can't affect them.

    BOOL resetDragMargins = [window _needsToResetDragMargins];

    [window _setNeedsToResetDragMargins:NO];

    [sv setDocumentView:view];

    [window _setNeedsToResetDragMargins:resetDragMargins];

    if (makeNewViewFirstResponder)

        [window makeFirstResponder:view];

    [sv setSuppressLayout:NO];

}

-(NSView <WebDocumentView> *)_makeDocumentViewForDataSource:(WebDataSource *)dataSource

{

    NSString* MIMEType = [dataSource _responseMIMEType];

    if (!MIMEType)

        MIMEType = @"text/html";

    Class viewClass = [self _viewClassForMIMEType:MIMEType];

    NSView <WebDocumentView> *documentView;

    if (viewClass) {

        // If the dataSource's representation has already been created, and it is also the

        // same class as the desired documentView, then use it as the documentView instead

        // of creating another one (Radar 4340787).

        id <WebDocumentRepresentation> dataSourceRepresentation = [dataSource representation];

        if (dataSourceRepresentation && [dataSourceRepresentation class] == viewClass)

            documentView = (NSView <WebDocumentView> *)[dataSourceRepresentation retain];

        else

            documentView = [[viewClass alloc] initWithFrame:[self bounds]];

    } else

        documentView = nil;

    [self _setDocumentView:documentView];

    [documentView release];

    return documentView;

}

- (void)_setWebFrame:(WebFrame *)webFrame

{

    if (!webFrame) {

        NSView *docV = [self documentView];

        if ([docV respondsToSelector:@selector(close)])

            [docV performSelector:@selector(close)];

    }

    // Not retained because the WebView owns the WebFrame, which owns the WebFrameView.

    _private->webFrame = webFrame;    

    if (!_private->includedInWebKitStatistics && [webFrame _isIncludedInWebKitStatistics]) {

        _private->includedInWebKitStatistics = YES;

        ++WebFrameViewCount;

    }

}

- (WebDynamicScrollBarsView *)_scrollView

{

    // This can be called by [super dealloc] when cleaning up the key view loop,

    // after _private has been nilled out.

    if (_private == nil)

        return nil;

    return _private->frameScrollView;

}

- (float)_verticalPageScrollDistance

{

    float height = [[self _contentView] bounds].size.height;

    return max<float>(height * Scrollbar::minFractionToStepWhenPaging(), height - Scrollbar::maxOverlapBetweenPages());

}

static inline void addTypesFromClass(NSMutableDictionary *allTypes, Class objCClass, NSArray *supportTypes)

{

    NSEnumerator *enumerator = [supportTypes objectEnumerator];

    ASSERT(enumerator != nil);

    NSString *mime = nil;

    while ((mime = [enumerator nextObject]) != nil) {

        // Don't clobber previously-registered classes.

        if ([allTypes objectForKey:mime] == nil)

            [allTypes setObject:objCClass forKey:mime];

    }

}

+ (NSMutableDictionary *)_viewTypesAllowImageTypeOmission:(BOOL)allowImageTypeOmission

{

    static NSMutableDictionary *viewTypes = nil;

    static BOOL addedImageTypes = NO;

    if (!viewTypes) {

        viewTypes = [[NSMutableDictionary alloc] init];

        addTypesFromClass(viewTypes, [WebHTMLView class], [WebHTMLView supportedNonImageMIMETypes]);

        // Since this is a "secret default" we don't bother registering it.

        BOOL omitPDFSupport = [[NSUserDefaults standardUserDefaults] boolForKey:@"WebKitOmitPDFSupport"];

        if (!omitPDFSupport)

            addTypesFromClass(viewTypes, [WebPDFView class], [WebPDFView supportedMIMETypes]);

    }

    if (!addedImageTypes && !allowImageTypeOmission) {

        addTypesFromClass(viewTypes, [WebHTMLView class], [WebHTMLView supportedImageMIMETypes]);

        addedImageTypes = YES;

    }

    return viewTypes;

}

+ (BOOL)_canShowMIMETypeAsHTML:(NSString *)MIMEType

{

    return [[[self _viewTypesAllowImageTypeOmission:YES] _webkit_objectForMIMEType:MIMEType] isSubclassOfClass:[WebHTMLView class]];

}

+ (Class)_viewClassForMIMEType:(NSString *)MIMEType allowingPlugins:(BOOL)allowPlugins

{

    Class viewClass;

    return [WebView _viewClass:&viewClass andRepresentationClass:nil forMIMEType:MIMEType allowingPlugins:allowPlugins] ? viewClass : nil;

}

- (Class)_viewClassForMIMEType:(NSString *)MIMEType

{

    return [[self class] _viewClassForMIMEType:MIMEType allowingPlugins:[[[self _webView] preferences] arePlugInsEnabled]];

}

- (void)_install

{

    ASSERT(_private->webFrame);

    ASSERT(_private->frameScrollView);

    Frame* frame = core(_private->webFrame);

    ASSERT(frame);

    ASSERT(frame->page());

    // If this isn't the main frame, it must have an owner element set, or it

    // won't ever get installed in the view hierarchy.

    ASSERT(frame == frame->page()->mainFrame() || frame->ownerElement());

    FrameView* view = frame->view();

    view->setPlatformWidget(_private->frameScrollView);

    // FIXME: Frame tries to do this too. Is this code needed?

    if (RenderPart* owner = frame->ownerRenderer()) {

        owner->setWidget(view);

        // Now the render part owns the view, so we don't any more.

    }

    view->updateCanHaveScrollbars();

}

@end

@implementation WebFrameView

- (id)initWithFrame:(NSRect)frame

{

    self = [super initWithFrame:frame];

    if (!self)

        return nil;

    static bool didFirstTimeInitialization;

    if (!didFirstTimeInitialization) {

        didFirstTimeInitialization = true;

        InitWebCoreSystemInterface();

        // Need to tell WebCore what function to call for the "History Item has Changed" notification.

        // Note: We also do this in WebHistoryItem's init method.

        WebCore::notifyHistoryItemChanged = WKNotifyHistoryItemChanged;

        [WebViewFactory createSharedFactory];

        [WebKeyGenerator createSharedGenerator];

// FIXME: Remove the NSAppKitVersionNumberWithDeferredWindowDisplaySupport check once

// once AppKit's Deferred Window Display support is available.

#if defined(BUILDING_ON_TIGER) || defined(BUILDING_ON_LEOPARD) || !defined(NSAppKitVersionNumberWithDeferredWindowDisplaySupport)

        // CoreGraphics deferred updates are disabled if WebKitEnableCoalescedUpdatesPreferenceKey is NO

        // or has no value. For compatibility with Mac OS X 10.5 and lower, deferred updates are off by default.

        if (![[NSUserDefaults standardUserDefaults] boolForKey:WebKitEnableDeferredUpdatesPreferenceKey])

            WKDisableCGDeferredUpdates();

#endif

        if (!WebKitLinkedOnOrAfter(WEBKIT_FIRST_VERSION_WITH_MAIN_THREAD_EXCEPTIONS))

            setDefaultThreadViolationBehavior(LogOnFirstThreadViolation, ThreadViolationRoundOne);

        bool throwExceptionsForRoundTwo = WebKitLinkedOnOrAfter(WEBKIT_FIRST_VERSION_WITH_ROUND_TWO_MAIN_THREAD_EXCEPTIONS);

#ifdef MAIL_THREAD_WORKAROUND

        // Even if old Mail is linked with new WebKit, don't throw exceptions.

        if ([WebResource _needMailThreadWorkaroundIfCalledOffMainThread])

            throwExceptionsForRoundTwo = false;

#endif

        if (!throwExceptionsForRoundTwo)

            setDefaultThreadViolationBehavior(LogOnFirstThreadViolation, ThreadViolationRoundTwo);

    }

    _private = [[WebFrameViewPrivate alloc] init];

    WebDynamicScrollBarsView *scrollView = [[WebDynamicScrollBarsView alloc] initWithFrame:NSMakeRect(0.0f, 0.0f, frame.size.width, frame.size.height)];

    _private->frameScrollView = scrollView;

    [scrollView setContentView:[[[WebClipView alloc] initWithFrame:[scrollView bounds]] autorelease]];

    [scrollView setDrawsBackground:NO];

    [scrollView setHasVerticalScroller:NO];

    [scrollView setHasHorizontalScroller:NO];

    [scrollView setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];

    [scrollView setLineScroll:Scrollbar::pixelsPerLineStep()];

    [self addSubview:scrollView];

    // Don't call our overridden version of setNextKeyView here; we need to make the standard NSView

    // link between us and our subview so that previousKeyView and previousValidKeyView work as expected.

    // This works together with our becomeFirstResponder and setNextKeyView overrides.

    [super setNextKeyView:scrollView];

    return self;

}

- (void)dealloc 

{

    if (_private && _private->includedInWebKitStatistics)

        --WebFrameViewCount;

    [_private release];

    _private = nil;

    [super dealloc];

}

- (void)finalize 

{

    if (_private && _private->includedInWebKitStatistics)

        --WebFrameViewCount;

    [super finalize];

}

- (WebFrame *)webFrame

{

    // This method can be called beneath -[NSView dealloc] after _private has been cleared.

    return _private ? _private->webFrame : nil;

}

- (void)setAllowsScrolling:(BOOL)flag

{

    WebCore::Frame *frame = core([self webFrame]);

    if (WebCore::FrameView *view = frame? frame->view() : 0)

        view->setCanHaveScrollbars(flag);

}

- (BOOL)allowsScrolling

{

    WebCore::Frame *frame = core([self webFrame]);

    if (WebCore::FrameView *view = frame? frame->view() : 0)

        return view->canHaveScrollbars();

    return YES;

}

- (NSView <WebDocumentView> *)documentView

{

    return [[self _scrollView] documentView];

}

- (BOOL)acceptsFirstResponder

{

    // We always accept first responder; this matches OS X 10.2 WebKit

    // behavior (see 3469791).

    return YES;

}

- (BOOL)becomeFirstResponder

{

    // This works together with setNextKeyView to splice the WebFrameView into

    // the key loop similar to the way NSScrollView does this. Note that

    // WebView has similar code.

    NSWindow *window = [self window];

    if ([window keyViewSelectionDirection] == NSSelectingPrevious) {

        NSView *previousValidKeyView = [self previousValidKeyView];

        // If we couldn't find a previous valid key view, ask the WebView. This handles frameset

        // cases (one is mentioned in Radar bug 3748628). Note that previousValidKeyView should

        // never be self but can be due to AppKit oddness (mentioned in Radar bug 3748628).

        if (previousValidKeyView == nil || previousValidKeyView == self)

            previousValidKeyView = [[[self webFrame] webView] previousValidKeyView];

        [window makeFirstResponder:previousValidKeyView];

    } else {

        // If the scroll view won't accept first-responderness now, then just become

        // the first responder ourself like a normal view. This lets us be the first 

        // responder in cases where no page has yet been loaded.

        if ([[self _scrollView] acceptsFirstResponder])

            [window makeFirstResponder:[self _scrollView]];

    }

    return YES;

}

- (void)setNextKeyView:(NSView *)aView

{

    // This works together with becomeFirstResponder to splice the WebFrameView into

    // the key loop similar to the way NSScrollView does this. Note that

    // WebView has very similar code.

    if ([self _scrollView] != nil) {

        [[self _scrollView] setNextKeyView:aView];

    } else {

        [super setNextKeyView:aView];

    }

}

- (BOOL)isOpaque

{

    return [[self _webView] drawsBackground];

}

- (void)drawRect:(NSRect)rect

{

    if ([self documentView] == nil) {

        // Need to paint ourselves if there's no documentView to do it instead.

        if ([[self _webView] drawsBackground]) {

            [[[self _webView] backgroundColor] set];

            NSRectFill(rect);

        }

    } else {

#ifndef NDEBUG

        if ([[self _scrollView] drawsBackground]) {

            [[NSColor cyanColor] set];

            NSRectFill(rect);

        }

#endif

    }

}

- (NSRect)visibleRect

{

    // This method can be called beneath -[NSView dealloc] after we have cleared _private.

    if (!_private)

        return [super visibleRect];

    // FIXME: <rdar://problem/6213380> This method does not work correctly with transforms, for two reasons:

    // 1) [super visibleRect] does not account for the transform, since it is not represented

    //    in the NSView hierarchy.

    // 2) -_getVisibleRect: does not correct for transforms.

    NSRect rendererVisibleRect;

    if (![[self webFrame] _getVisibleRect:&rendererVisibleRect])

        return [super visibleRect];

    if (NSIsEmptyRect(rendererVisibleRect))

        return NSZeroRect;

    NSRect viewVisibleRect = [super visibleRect];

    if (NSIsEmptyRect(viewVisibleRect))

        return NSZeroRect;

    NSRect frame = [self frame];

    // rendererVisibleRect is in the parent's coordinate space, and frame is in the superview's coordinate space.

    // The return value from this method needs to be in this view's coordinate space. We get that right by subtracting

    // the origins (and correcting for flipping), but when we support transforms, we will need to do better than this.

    rendererVisibleRect.origin.x -= frame.origin.x;

    rendererVisibleRect.origin.y = NSMaxY(frame) - NSMaxY(rendererVisibleRect);

    return NSIntersectionRect(rendererVisibleRect, viewVisibleRect);

}

- (void)setFrameSize:(NSSize)size

{

    if (!NSEqualSizes(size, [self frame].size)) {

        // See WebFrameLoaderClient::provisionalLoadStarted.

        if ([[[self webFrame] webView] drawsBackground])

            [[self _scrollView] setDrawsBackground:YES];

        if (Frame* coreFrame = [self _web_frame]) {

            if (FrameView* coreFrameView = coreFrame->view())

                coreFrameView->setNeedsLayout();

        }

    }

    [super setFrameSize:size];

}

- (void)viewDidMoveToWindow

{

    // See WebFrameLoaderClient::provisionalLoadStarted.

    // Need to check _private for nil because this can be called inside -[WebView initWithCoder:].

    if (_private && [[[self webFrame] webView] drawsBackground])

        [[self _scrollView] setDrawsBackground:YES];

    [super viewDidMoveToWindow];

}

- (BOOL)_scrollOverflowInDirection:(ScrollDirection)direction granularity:(ScrollGranularity)granularity

{

    // scrolling overflows is only applicable if we're dealing with an WebHTMLView

    if (![[self documentView] isKindOfClass:[WebHTMLView class]])

        return NO;

    Frame* frame = core([self webFrame]);

    if (!frame)

        return NO;