/*

 * Copyright (C) 2005, 2006 Apple Computer, 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 "WebDataSource.h"

#import "WebDocument.h"

#import "WebDynamicScrollBarsView.h"

#import "WebFrame.h"

#import "WebFrameInternal.h"

#import "WebFrameBridge.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 "WebSystemInterface.h"

#import "WebViewFactory.h"

#import "WebViewInternal.h"

#import "WebViewPrivate.h"

#import <Foundation/NSURLRequest.h>

#import <JavaScriptCore/Assertions.h>

#import <WebCore/DragController.h>

#import <WebCore/Frame.h>

#import <WebCore/FrameView.h>

#import <WebCore/HistoryItem.h>

#import <WebCore/Page.h>

#import <WebCore/ThreadCheck.h>

#import <WebCore/WebCoreFrameView.h>

#import <WebCore/WebCoreView.h>

#import <WebKitSystemInterface.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) <WebCoreBridgeHolder>

- (float)_verticalKeyboardScrollDistance;

- (WebCoreFrameBridge *) webCoreBridge;

@end

@interface WebFrameViewPrivate : NSObject {

@public

    WebFrame *webFrame;

    WebDynamicScrollBarsView *frameScrollView;

    // These margin values are used to temporarily hold the margins of a frame until

    // we have the appropriate document view type.

    int marginWidth;

    int marginHeight;

}

@end

@implementation WebFrameViewPrivate

- init

{

    [super init];

    marginWidth = -1;

    marginHeight = -1;

    return self;

}

- (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];

}

- (WebCoreFrameBridge *) webCoreBridge

{

    return [_private->webFrame _bridge];

}

@end

@implementation WebFrameView (WebInternal)

// Note that the WebVew is not retained.

- (WebView *)_webView

{

    return [_private->webFrame webView];

}

- (void)_setMarginWidth:(int)w

{

    _private->marginWidth = w;

}

- (int)_marginWidth

{

    return _private->marginWidth;

}

- (void)_setMarginHeight:(int)h

{

    _private->marginHeight = h;

}

- (int)_marginHeight

{

    return _private->marginHeight;

}

- (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 response] MIMEType];

    if (!MIMEType)

        MIMEType = @"text/html";

    Class viewClass = [[self class] _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;    

}

- (WebDynamicScrollBarsView *)_scrollView

{

    // this can be called by [super dealloc] when cleaning up the keyview loop,

    // after _private has been nilled out.

    if (_private == nil) {

        return nil;

    }

    return _private->frameScrollView;

}

- (float)_verticalPageScrollDistance

{

    float overlap = [self _verticalKeyboardScrollDistance];

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

    return (height < overlap) ? height / 2 : height - overlap;

}

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 both 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

{

    Class viewClass;

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

}

@end

@implementation WebFrameView

- 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];

        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];

        // CoreGraphics deferred updates are disabled if WebKitEnableCoalescedUpdatesPreferenceKey is set

        // to NO, or has no value.  For compatibility with Mac OS X 10.4.6, deferred updates are OFF by

        // default.

        if (![defaults boolForKey:WebKitEnableDeferredUpdatesPreferenceKey])

            WKDisableCGDeferredUpdates();

        if (!WebKitLinkedOnOrAfter(WEBKIT_FIRST_VERSION_WITH_MAIN_THREAD_EXCEPTIONS))

            setDefaultThreadViolationBehavior(LogOnFirstThreadViolation);

    }

    _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:40.0f];

    [self addSubview:scrollView];

    // don't call our overridden version 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];

    ++WebFrameViewCount;

    return self;

}

- (void)dealloc 

{

    --WebFrameViewCount;

    [_private release];

    _private = nil;

    [super dealloc];

}

- (void)finalize 

{

    --WebFrameViewCount;

    [super finalize];

}

- (WebFrame *)webFrame

{

    return _private->webFrame;

}

- (void)setAllowsScrolling:(BOOL)flag

{

    WebDynamicScrollBarsView *scrollView = [self _scrollView];

    [scrollView setAllowsScrolling:flag];

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

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

        view->setHScrollbarMode((WebCore::ScrollbarMode)[scrollView horizontalScrollingMode]);

        view->setVScrollbarMode((WebCore::ScrollbarMode)[scrollView verticalScrollingMode]);

    }

}

- (BOOL)allowsScrolling

{

    return [[self _scrollView] allowsScrolling];

}

- (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.

    // If the scrollView won't accept first-responderness now, then we 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 (see 3469791).

    if ([[self _scrollView] acceptsFirstResponder]) {

        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 like 3748628. Note that previousValidKeyView should never be self but can be

            // due to AppKit oddness (mentioned in 3748628).

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

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

            }

            // I don't know if the following cases ever occur anymore, but I'm leaving in the old test for

            // now to avoid causing trouble just before shipping Tiger.

            ASSERT((previousValidKeyView != self) && (previousValidKeyView != [self _scrollView]));

            if ((previousValidKeyView != self) && (previousValidKeyView != [self _scrollView])) {

                [window makeFirstResponder:previousValidKeyView];

            }

        } else {

            [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

    }

}

- (void)setFrameSize:(NSSize)size

{

    if (!NSEqualSizes(size, [self frame].size) && [[[self webFrame] webView] drawsBackground]) {

        [[self _scrollView] setDrawsBackground:YES];

    }

    [super setFrameSize:size];

}

- (WebFrameBridge *)_bridge

{

    return [[self webFrame] _bridge];

}

- (BOOL)_scrollOverflowInDirection:(WebScrollDirection)direction granularity:(WebScrollGranularity)granularity

{

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

    return ([[self documentView] isKindOfClass:[WebHTMLView class]] && [[self _bridge] scrollOverflowInDirection:direction granularity:granularity]);

}

- (void)scrollToBeginningOfDocument:(id)sender

{

    if (![self _scrollOverflowInDirection:WebScrollUp granularity:WebScrollDocument]) {

        if (![self _hasScrollBars]) {

            [[self _largestChildWithScrollBars] scrollToBeginningOfDocument:sender];

            return;

        }

        [[self _contentView] scrollPoint:[[[self _scrollView] documentView] frame].origin];

    }

}

- (void)scrollToEndOfDocument:(id)sender

{

    if (![self _scrollOverflowInDirection:WebScrollDown granularity:WebScrollDocument]) {

        if (![self _hasScrollBars]) {

            [[self _largestChildWithScrollBars] scrollToEndOfDocument:sender];

            return;

        }

        NSRect frame = [[[self _scrollView] documentView] frame];

        [[self _contentView] scrollPoint:NSMakePoint(frame.origin.x, NSMaxY(frame))];

    }

}

- (void)_goBack

{

    [[self _webView] goBack];

}

- (void)_goForward

{

    [[self _webView] goForward];

}

- (BOOL)_scrollVerticallyBy:(float)delta

{

    // This method uses the secret method _scrollTo on NSClipView.

    // It does that because it needs to know definitively whether scrolling was

    // done or not to help implement the "scroll parent if we are at the limit" feature.

    // In the presence of smooth scrolling, there's no easy way to tell if the method

    // did any scrolling or not with the public API.

    NSPoint point = [[self _contentView] bounds].origin;

    point.y += delta;

    return [[self _contentView] _scrollTo:&point animate:YES];

}