/*

 * Copyright (C) 2006, 2007 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.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 COMPUTER, INC. OR

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

 */

#include "config.h"

#include "WebKitDLL.h"

#include "WebView.h"

#include "CFDictionaryPropertyBag.h"

#include "DOMCoreClasses.h"

#include "IWebNotification.h"

#include "WebDebugProgram.h"

#include "WebDocumentLoader.h"

#include "WebEditorClient.h"

#include "WebElementPropertyBag.h"

#include "WebFrame.h"

#include "WebBackForwardList.h"

#include "WebChromeClient.h"

#include "WebContextMenuClient.h"

#include "WebDragClient.h"

#include "WebIconDatabase.h"

#include "WebInspectorClient.h"

#include "WebKit.h"

#include "WebKitStatisticsPrivate.h"

#include "WebMutableURLRequest.h"

#include "WebNotificationCenter.h"

#include "WebPreferences.h"

#pragma warning( push, 0 )

#include <CoreGraphics/CGContext.h>

#include <WebCore/BString.h>

#include <WebCore/Cache.h>

#include <WebCore/CommandByName.h>

#include <WebCore/ContextMenu.h>

#include <WebCore/ContextMenuController.h>

#include <WebCore/CString.h>

#include <WebCore/Cursor.h>

#include <WebCore/Document.h>

#include <WebCore/DragController.h>

#include <WebCore/DragData.h>

#include <WebCore/Editor.h>

#include <WebCore/EventHandler.h>

#include <WebCore/FocusController.h>

#include <WebCore/FrameLoader.h>

#include <WebCore/FrameTree.h>

#include <WebCore/FrameView.h>

#include <WebCore/FrameWin.h>

#include <WebCore/GDIObjectCounter.h>

#include <WebCore/GraphicsContext.h>

#include <WebCore/HistoryItem.h>

#include <WebCore/HitTestResult.h>

#include <WebCore/IntRect.h>

#include <WebCore/KeyboardEvent.h>

#include <WebCore/Language.h>

#include <WebCore/MIMETypeRegistry.h>

#include <WebCore/NotImplemented.h>

#include <WebCore/Page.h>

#include <WebCore/PageCache.h>

#include <WebCore/PlatformKeyboardEvent.h>

#include <WebCore/PlatformMouseEvent.h>

#include <WebCore/PlatformWheelEvent.h>

#include <WebCore/PluginDatabaseWin.h>

#include <WebCore/PlugInInfoStore.h>

#include <WebCore/ProgressTracker.h>

#include <WebCore/ResourceHandle.h>

#include <WebCore/ResourceHandleClient.h>

#include <WebCore/SelectionController.h>

#include <WebCore/Settings.h>

#include <WebCore/TypingCommand.h>

#pragma warning(pop)

#include <JavaScriptCore/collector.h>

#include <JavaScriptCore/value.h>

#include <CFNetwork/CFURLProtocolPriv.h>

#include <WebKitSystemInterface/WebKitSystemInterface.h>

#include <tchar.h>

#include <dimm.h>

#include <windowsx.h>

#include <ShlObj.h>

using namespace WebCore;

using KJS::JSLock;

using std::min;

const LPCWSTR kWebViewWindowClassName = L"WebViewWindowClass";

const int WM_XP_THEMECHANGED = 0x031A;

const int WM_VISTA_MOUSEHWHEEL = 0x020E;

static const int maxToolTipWidth = 250;

static ATOM registerWebView();

static LRESULT CALLBACK WebViewWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

HRESULT createMatchEnumerator(Vector<IntRect>* rects, IEnumTextMatches** matches);

static bool continuousSpellCheckingEnabled;

static bool grammarCheckingEnabled;

// WebView ----------------------------------------------------------------

bool WebView::s_allowSiteSpecificHacks = false;

WebView::WebView()

: m_refCount(0)

, m_hostWindow(0)

, m_viewWindow(0)

, m_mainFrame(0)

, m_page(0)

, m_hasCustomDropTarget(false)

, m_useBackForwardList(true)

, m_userAgentOverridden(false)

, m_textSizeMultiplier(1)

, m_mouseActivated(false)

, m_dragData(0)

, m_currentCharacterCode(0)

, m_isBeingDestroyed(false)

, m_paintCount(0)

, m_hasSpellCheckerDocumentTag(false)

, m_smartInsertDeleteEnabled(false)

, m_didClose(false)

, m_inIMEComposition(0)

, m_toolTipHwnd(0)

, m_closeWindowTimer(this, &WebView::closeWindowTimerFired)

{

    KJS::Collector::registerAsMainThread();

    m_backingStoreSize.cx = m_backingStoreSize.cy = 0;

    CoCreateInstance(CLSID_DragDropHelper, 0, CLSCTX_INPROC_SERVER, IID_IDropTargetHelper,(void**)&m_dropTargetHelper);

    COMPtr<IWebPreferences> prefs;

    if (SUCCEEDED(preferences(&prefs))) {

        BOOL enabled;

        if (SUCCEEDED(prefs->continuousSpellCheckingEnabled(&enabled)))

            continuousSpellCheckingEnabled = !!enabled;

        if (SUCCEEDED(prefs->grammarCheckingEnabled(&enabled)))

            grammarCheckingEnabled = !!enabled;

    }

    WebDebugProgram::viewAdded(this);

    WebViewCount++;

    gClassCount++;

}

WebView::~WebView()

{

    deleteBackingStore();

    // <rdar://4958382> m_viewWindow will be destroyed when m_hostWindow is destroyed, but if

    // setHostWindow was never called we will leak our HWND. If we still have a valid HWND at

    // this point, we should just destroy it ourselves.

    if (::IsWindow(m_viewWindow))

        ::DestroyWindow(m_viewWindow);

    delete m_page;

    WebDebugProgram::viewRemoved(this);

    WebViewCount--;

    gClassCount--;

}

WebView* WebView::createInstance()

{

    WebView* instance = new WebView();

    instance->AddRef();

    return instance;

}

void WebView::close()

{

    if (m_didClose)

        return;

    m_didClose = true;

    Frame* frame = m_page->mainFrame();

    if (frame)

        frame->loader()->detachFromParent();

    m_page->setGroupName(String());

    setHostWindow(0);

    setDownloadDelegate(0);

    setEditingDelegate(0);

    setFrameLoadDelegate(0);

    setFrameLoadDelegatePrivate(0);

    setPolicyDelegate(0);

    setResourceLoadDelegate(0);

    setUIDelegate(0);

    setFormDelegate(0);

    delete m_page;

    m_page = 0;

    registerForIconNotification(false);

    IWebNotificationCenter* notifyCenter = WebNotificationCenter::defaultCenterInternal();

    COMPtr<IWebPreferences> prefs;

    if (SUCCEEDED(preferences(&prefs)))

        notifyCenter->removeObserver(this, WebPreferences::webPreferencesChangedNotification(), prefs.get());

    prefs = 0;  // make sure we release the reference, since WebPreferences::removeReferenceForIdentifier will check for last reference to WebPreferences

    if (m_preferences) {

        BSTR identifier = 0;

        if (SUCCEEDED(m_preferences->identifier(&identifier)))

            WebPreferences::removeReferenceForIdentifier(identifier);

        if (identifier)

            SysFreeString(identifier);

        m_preferences = 0;

    }

    deleteBackingStore();

}

void WebView::deleteBackingStore()

{

    m_backingStoreBitmap.clear();

    m_backingStoreDirtyRegion.clear();

    m_backingStoreSize.cx = m_backingStoreSize.cy = 0;

}

bool WebView::ensureBackingStore()

{

    RECT windowRect;

    ::GetClientRect(m_viewWindow, &windowRect);

    LONG width = windowRect.right - windowRect.left;

    LONG height = windowRect.bottom - windowRect.top;

    if (width > 0 && height > 0 && (width != m_backingStoreSize.cx || height != m_backingStoreSize.cy)) {

        deleteBackingStore();

        m_backingStoreSize.cx = width;

        m_backingStoreSize.cy = height;

        BITMAPINFO bitmapInfo;

        bitmapInfo.bmiHeader.biSize          = sizeof(BITMAPINFOHEADER);

        bitmapInfo.bmiHeader.biWidth         = width; 

        bitmapInfo.bmiHeader.biHeight        = -height;

        bitmapInfo.bmiHeader.biPlanes        = 1;

        bitmapInfo.bmiHeader.biBitCount      = 32;

        bitmapInfo.bmiHeader.biCompression   = BI_RGB;

        bitmapInfo.bmiHeader.biSizeImage     = 0;

        bitmapInfo.bmiHeader.biXPelsPerMeter = 0;

        bitmapInfo.bmiHeader.biYPelsPerMeter = 0;

        bitmapInfo.bmiHeader.biClrUsed       = 0;

        bitmapInfo.bmiHeader.biClrImportant  = 0;

        void* pixels = NULL;

        m_backingStoreBitmap.set(::CreateDIBSection(NULL, &bitmapInfo, DIB_RGB_COLORS, &pixels, NULL, 0));

        return true;

    }

    return false;

}

void WebView::addToDirtyRegion(const IntRect& dirtyRect)

{

    HRGN newRegion = ::CreateRectRgn(dirtyRect.x(), dirtyRect.y(),

                                     dirtyRect.right(), dirtyRect.bottom());

    addToDirtyRegion(newRegion);

}

void WebView::addToDirtyRegion(HRGN newRegion)

{

    LOCAL_GDI_COUNTER(0, __FUNCTION__);

    if (m_backingStoreDirtyRegion) {

        HRGN combinedRegion = ::CreateRectRgn(0,0,0,0);

        ::CombineRgn(combinedRegion, m_backingStoreDirtyRegion.get(), newRegion, RGN_OR);

        ::DeleteObject(newRegion);

        m_backingStoreDirtyRegion.set(combinedRegion);

    } else

        m_backingStoreDirtyRegion.set(newRegion);

}

void WebView::scrollBackingStore(FrameView* frameView, int dx, int dy, const IntRect& scrollViewRect, const IntRect& clipRect)

{

    LOCAL_GDI_COUNTER(0, __FUNCTION__);

    // If there's no backing store we don't need to update it

    if (!m_backingStoreBitmap) {

        if (m_uiDelegatePrivate)

            m_uiDelegatePrivate->webViewScrolled(this);

        return;

    }

    // Make a region to hold the invalidated scroll area.

    HRGN updateRegion = ::CreateRectRgn(0, 0, 0, 0);

    // Collect our device context info and select the bitmap to scroll.

    HDC windowDC = ::GetDC(m_viewWindow);

    HDC bitmapDC = ::CreateCompatibleDC(windowDC);

    ::SelectObject(bitmapDC, m_backingStoreBitmap.get());

    // Scroll the bitmap.

    RECT scrollRectWin(scrollViewRect);

    RECT clipRectWin(clipRect);

    ::ScrollDC(bitmapDC, dx, dy, &scrollRectWin, &clipRectWin, updateRegion, 0);

    RECT regionBox;

    ::GetRgnBox(updateRegion, &regionBox);

    // Flush.

    GdiFlush();

    // Add the dirty region to the backing store's dirty region.

    addToDirtyRegion(updateRegion);

    if (m_uiDelegatePrivate)

        m_uiDelegatePrivate->webViewScrolled(this);

    // Update the backing store.

    updateBackingStore(frameView, bitmapDC, false);

    // Clean up.

    ::DeleteDC(bitmapDC);

    ::ReleaseDC(m_viewWindow, windowDC);

}

void WebView::updateBackingStore(FrameView* frameView, HDC dc, bool backingStoreCompletelyDirty)

{

    LOCAL_GDI_COUNTER(0, __FUNCTION__);

    HDC windowDC = 0;

    HDC bitmapDC = dc;

    if (!dc) {

        windowDC = ::GetDC(m_viewWindow);

        bitmapDC = ::CreateCompatibleDC(windowDC);

        ::SelectObject(bitmapDC, m_backingStoreBitmap.get());

    }

    if (m_backingStoreBitmap && (m_backingStoreDirtyRegion || backingStoreCompletelyDirty)) {

        // Do a layout first so that everything we render to the backing store is always current.

        if (Frame* coreFrame = core(m_mainFrame))

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

                view->layoutIfNeededRecursive();

        // This emulates the Mac smarts for painting rects intelligently.  This is

        // very important for us, since we double buffer based off dirty rects.

        bool useRegionBox = true;

        const int cRectThreshold = 10;

        const float cWastedSpaceThreshold = 0.75f;

        RECT regionBox;

        if (!backingStoreCompletelyDirty) {

            ::GetRgnBox(m_backingStoreDirtyRegion.get(), &regionBox);

            DWORD regionDataSize = GetRegionData(m_backingStoreDirtyRegion.get(), sizeof(RGNDATA), NULL);

            if (regionDataSize) {

                RGNDATA* regionData = (RGNDATA*)malloc(regionDataSize);

                GetRegionData(m_backingStoreDirtyRegion.get(), regionDataSize, regionData);

                if (regionData->rdh.nCount <= cRectThreshold) {

                    double unionPixels = (regionBox.right - regionBox.left) * (regionBox.bottom - regionBox.top);

                    double singlePixels = 0;

                    unsigned i;

                    RECT* rect;

                    for (i = 0, rect = (RECT*)regionData->Buffer; i < regionData->rdh.nCount; i++, rect++)

                        singlePixels += (rect->right - rect->left) * (rect->bottom - rect->top);

                    double wastedSpace = 1.0 - (singlePixels / unionPixels);

                    if (wastedSpace > cWastedSpaceThreshold) {

                        // Paint individual rects.

                        useRegionBox = false;

                        for (i = 0, rect = (RECT*)regionData->Buffer; i < regionData->rdh.nCount; i++, rect++)

                            paintIntoBackingStore(frameView, bitmapDC, rect);

                    }

                }

                free(regionData);

            }

        } else

            ::GetClientRect(m_viewWindow, &regionBox);

        if (useRegionBox)

            paintIntoBackingStore(frameView, bitmapDC, &regionBox);

        if (m_uiDelegatePrivate) {

            COMPtr<IWebUIDelegatePrivate2> uiDelegatePrivate2(Query, m_uiDelegatePrivate);

            if (uiDelegatePrivate2)

                uiDelegatePrivate2->webViewPainted(this);

        }

        m_backingStoreDirtyRegion.clear();

    }

    if (!dc) {

        ::DeleteDC(bitmapDC);

        ::ReleaseDC(m_viewWindow, windowDC);

    }

    GdiFlush();

}

void WebView::paint(HDC dc, LPARAM options)

{

    LOCAL_GDI_COUNTER(0, __FUNCTION__);

    Frame* coreFrame = core(m_mainFrame);

    if (!coreFrame)

        return;

    FrameView* frameView = coreFrame->view();

    m_paintCount++;

    RECT rcPaint;

    HDC hdc;

    OwnPtr<HRGN> region;

    int regionType = NULLREGION;

    PAINTSTRUCT ps;

    if (!dc) {

        region.set(CreateRectRgn(0,0,0,0));

        regionType = GetUpdateRgn(m_viewWindow, region.get(), false);

        hdc = BeginPaint(m_viewWindow, &ps);

        rcPaint = ps.rcPaint;

    } else {

        hdc = dc;

        ::GetClientRect(m_viewWindow, &rcPaint);

        if (options & PRF_ERASEBKGND)

            ::FillRect(hdc, &rcPaint, (HBRUSH)GetStockObject(WHITE_BRUSH));

    }

    HDC bitmapDC = ::CreateCompatibleDC(hdc);

    bool backingStoreCompletelyDirty = ensureBackingStore();

    ::SelectObject(bitmapDC, m_backingStoreBitmap.get());

    // Update our backing store if needed.

    updateBackingStore(frameView, bitmapDC, backingStoreCompletelyDirty);

    // Now we blit the updated backing store

    IntRect windowDirtyRect = rcPaint;

    // Apply the same heuristic for this update region too.

    bool useWindowDirtyRect = true;

    if (region && regionType == COMPLEXREGION) {

        LOCAL_GDI_COUNTER(1, __FUNCTION__" (COMPLEXREGION)");

        const int cRectThreshold = 10;

        const float cWastedSpaceThreshold = 0.75f;

        DWORD regionDataSize = GetRegionData(region.get(), sizeof(RGNDATA), NULL);

        if (regionDataSize) {

            RGNDATA* regionData = (RGNDATA*)malloc(regionDataSize);

            GetRegionData(region.get(), regionDataSize, regionData);

            if (regionData->rdh.nCount <= cRectThreshold) {

                double unionPixels = windowDirtyRect.width() * windowDirtyRect.height();

                double singlePixels = 0;

                unsigned i;

                RECT* rect;

                for (i = 0, rect = (RECT*)regionData->Buffer; i < regionData->rdh.nCount; i++, rect++)

                    singlePixels += (rect->right - rect->left) * (rect->bottom - rect->top);

                double wastedSpace = 1.0 - (singlePixels / unionPixels);

                if (wastedSpace > cWastedSpaceThreshold) {

                    // Paint individual rects.

                    useWindowDirtyRect = false;

                    for (i = 0, rect = (RECT*)regionData->Buffer; i < regionData->rdh.nCount; i++, rect++)

                        paintIntoWindow(bitmapDC, hdc, rect);

                }

            }

            free(regionData);

        }

    }

    if (useWindowDirtyRect)

        paintIntoWindow(bitmapDC, hdc, &rcPaint);

    ::DeleteDC(bitmapDC);

    // Paint the gripper.

    COMPtr<IWebUIDelegate> ui;

    if (SUCCEEDED(uiDelegate(&ui))) {

        COMPtr<IWebUIDelegatePrivate> uiPrivate;

        if (SUCCEEDED(ui->QueryInterface(IID_IWebUIDelegatePrivate, (void**)&uiPrivate))) {

            RECT r;

            if (SUCCEEDED(uiPrivate->webViewResizerRect(this, &r))) {

                LOCAL_GDI_COUNTER(2, __FUNCTION__" webViewDrawResizer delegate call");

                uiPrivate->webViewDrawResizer(this, hdc, (frameView->resizerOverlapsContent() ? true : false), &r);

            }

        }

    }

    if (!dc)

        EndPaint(m_viewWindow, &ps);

    m_paintCount--;

}

void WebView::paintIntoBackingStore(FrameView* frameView, HDC bitmapDC, LPRECT dirtyRect)

{

    LOCAL_GDI_COUNTER(0, __FUNCTION__);

#if FLASH_BACKING_STORE_REDRAW

    HDC dc = ::GetDC(m_viewWindow);

    OwnPtr<HBRUSH> yellowBrush = CreateSolidBrush(RGB(255, 255, 0));

    FillRect(dc, dirtyRect, yellowBrush.get());

    GdiFlush();

    Sleep(50);

    paintIntoWindow(bitmapDC, dc, dirtyRect);

    ::ReleaseDC(m_viewWindow, dc);

#endif

    FillRect(bitmapDC, dirtyRect, (HBRUSH)GetStockObject(WHITE_BRUSH));

    if (frameView && frameView->frame() && frameView->frame()->renderer()) {

        GraphicsContext gc(bitmapDC);

        gc.save();

        gc.clip(IntRect(*dirtyRect));

        frameView->paint(&gc, IntRect(*dirtyRect));

        gc.restore();

    }

}

void WebView::paintIntoWindow(HDC bitmapDC, HDC windowDC, LPRECT dirtyRect)

{

    LOCAL_GDI_COUNTER(0, __FUNCTION__);

#if FLASH_WINDOW_REDRAW