/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

*

*/

#include "config.h"

#include <stdio.h>

#include <stdlib.h>

#include "Node.h"

#include "Event.h"

#include "FileChooser.h"

#include "Font.h"

#include "IntPoint.h"

#include "Widget.h"

#include "GraphicsContext.h"

#include "Cursor.h"

#include "loader.h"

#include "KURL.h"

#include "Scrollbar.h"

#include "Scrollbar.h"

#include "Path.h"

#include "PlatformScrollbar.h"

#include "PlatformMouseEvent.h"

#include "CookieJar.h"

#include "Screen.h"

#include "History.h"

#include "Language.h"

#include "LocalizedStrings.h"

#include "RenderTheme.h"

//#include "BrowserExtensionWin.h"

//#include "RenderThemeWin.h"

#include "TextBoundaries.h"

#include "AXObjectCache.h"

//#include "RenderPopupMenuWin.h"

#include "Icon.h"

#include "IconDatabase.h"

#include "Editor.h"

#include "ClipboardAccessPolicy.h"

#include "Clipboard.h"

#include "Sound.h"

#include "PageCache.h"

#include "SystemTime.h"

#include "AffineTransform.h"

#include "Path.h"

#include "ContextMenu.h"

#include "HitTestResult.h"

#include "ScrollView.h"

#include "SearchPopupMenu.h"

#include "Frame.h"

#include "FrameView.h"

#include "AffineTransform.h"

#include "DragData.h"

#include "DocumentFragment.h"

namespace WebCore {

static void notImplemented() { /*puts("Not yet implemented"); */}

void Widget::removeFromParent() { }

Cursor::Cursor(Image*, const IntPoint&) { notImplemented(); }

String searchableIndexIntroduction() { notImplemented(); return String(); }

int findNextSentenceFromIndex(UChar const*,int,int,bool) { notImplemented(); return 0; }

void findSentenceBoundary(UChar const*,int,int,int*,int*) { notImplemented(); }

int findNextWordFromIndex(UChar const*,int,int,bool) { notImplemented(); return 0; }

Vector<char> ServeSynchronousRequest(Loader*, DocLoader*, const ResourceRequest&, ResourceResponse&) { notImplemented(); return Vector<char>(); }

void GraphicsContext::addInnerRoundedRectClip(const IntRect& rect, int thickness) { notImplemented(); }

int screenDepthPerComponent(const Widget*) { notImplemented(); return 0; }

bool screenIsMonochrome(const Widget*) { notImplemented(); return false; }

/********************************************************/

/* Completely empty stubs (mostly to allow DRT to run): */

/********************************************************/

static Cursor localCursor;

const Cursor& moveCursor() { return localCursor; }

bool AXObjectCache::gAccessibilityEnabled = false;

//bool historyContains(DeprecatedString const&) { return false; }

String submitButtonDefaultLabel() { return "Submit"; }

String inputElementAltText() { return DeprecatedString(); }

String resetButtonDefaultLabel() { return "Reset"; }

String defaultLanguage() { return "en"; }

void findWordBoundary(UChar const* str,int len,int position,int* start, int* end) {*start=position; *end=position; }

bool CheckIfReloading(DocLoader*) { return false; }

void CheckCacheObjectStatus(DocLoader*, CachedResource*) { }

int NumberOfPendingOrLoadingRequests(DocLoader*) { return 0; }

void GraphicsContext::setShadow(IntSize const&,int,Color const&) { }

void GraphicsContext::clearShadow() { }

void GraphicsContext::beginTransparencyLayer(float) { }

void GraphicsContext::endTransparencyLayer() { }

void GraphicsContext::clearRect(const FloatRect&) { }

void GraphicsContext::strokeRect(const FloatRect&, float) { }

void GraphicsContext::setLineCap(LineCap) { }

void GraphicsContext::setLineJoin(LineJoin) { }

void GraphicsContext::setMiterLimit(float) { }

void GraphicsContext::setAlpha(float) { }

void GraphicsContext::setCompositeOperation(CompositeOperator) { }

void GraphicsContext::clip(const Path&) { }

void GraphicsContext::translate(float x, float y) { }

void GraphicsContext::rotate(float) { }

void GraphicsContext::scale(const FloatSize&) { }

void Path::moveTo(const FloatPoint&) { }

void Path::addQuadCurveTo(const FloatPoint&, const FloatPoint&) { }

void Path::addBezierCurveTo(const FloatPoint&, const FloatPoint&, const FloatPoint&) { }

void Path::addArcTo(const FloatPoint&, const FloatPoint&, float) { }

void Path::addArc(const FloatPoint&, float, float, float, bool) { }

void Path::apply(void* info, PathApplierFunction) const { }

Color focusRingColor() { return 0xFF0000FF; }

void setFocusRingColorChangeFunction(void (*)()) { }

String signedPublicKeyAndChallengeString(unsigned keySizeIndex, const String& challengeString, const KURL&) { return String(); }

Vector<String> supportedKeySizes() { return Vector<String>(); }

Icon::Icon() { notImplemented(); }

Icon::~Icon() { notImplemented(); }

PassRefPtr<Icon> Icon::newIconForFile(const String& filename) { notImplemented(); return PassRefPtr<Icon>(new Icon()); }

void Icon::paint(GraphicsContext*, const IntRect&) { notImplemented(); }

void Widget::invalidate() { }

void Widget::invalidateRect(const IntRect& r) { }

String fileButtonChooseFileLabel() { return "Choose File"; }

// editor

PassRefPtr<Clipboard> Editor::newGeneralClipboard(ClipboardAccessPolicy policy) { return 0; }

void systemBeep() { }

float userIdleTime()                                       { notImplemented(); return 0.0; }

IntSize dragImageSize(void *)                              { notImplemented(); return IntSize(); }

void deleteDragImage(void *)                               { notImplemented(); }

// AffineTransform

AffineTransform::AffineTransform()                                  { notImplemented(); }

AffineTransform& AffineTransform::scale(double sx, double sy)       { notImplemented(); return *this; }

AffineTransform& AffineTransform::rotate(double sx)                 { notImplemented(); return *this; }

AffineTransform& AffineTransform::translate(double, double)         { notImplemented(); return *this; }

// Path

void Path::transform(const AffineTransform&)               { notImplemented(); }

// ContextMenu

ContextMenu::ContextMenu(const HitTestResult& h) : m_hitTestResult(h)   { notImplemented(); }

ContextMenu::~ContextMenu()                                             { notImplemented(); }

void ContextMenu::setPlatformDescription(void* )                        { notImplemented(); }

String ContextMenuItem::title() const									{ notImplemented(); return String(); }

ContextMenuAction ContextMenuItem::action() const						{ notImplemented(); return ContextMenuItemTagNoAction; }

void ContextMenuItem::setEnabled(bool)									{ notImplemented(); }

void ContextMenuItem::setChecked(bool)									{ notImplemented(); }

ContextMenuItemType ContextMenuItem::type() const						{ notImplemented(); return ActionType; }

ContextMenuItem::ContextMenuItem(ContextMenuItemType, ContextMenuAction, const String&, ContextMenu *)  { notImplemented(); }

ContextMenuItem::~ContextMenuItem()                                     { notImplemented(); }

void ContextMenuItem::setSubMenu(ContextMenu *)                { notImplemented(); }

void ContextMenu::appendItem(ContextMenuItem &)                { notImplemented(); }

String contextMenuItemTagShowSpellingPanel(bool show)                   { notImplemented(); return String(); }

String contextMenuItemTagCheckSpelling()                                { notImplemented(); return String(); }

String contextMenuItemTagCheckSpellingWhileTyping()                     { notImplemented(); return String(); }

String contextMenuItemTagCheckGrammarWithSpelling()                     { notImplemented(); return String(); }

String contextMenuItemTagBold()                                         { notImplemented(); return String(); }

String contextMenuItemTagItalic()                                       { notImplemented(); return String(); }

String contextMenuItemTagUnderline()                                    { notImplemented(); return String(); }

String contextMenuItemTagOutline()                                      { notImplemented(); return String(); }

String contextMenuItemTagNoGuessesFound()                               { notImplemented(); return String(); }

String contextMenuItemTagOpenFrameInNewWindow()                         { notImplemented(); return String(); }

String contextMenuItemTagStop()                                         { notImplemented(); return String(); }

String contextMenuItemTagGoForward()                                    { notImplemented(); return String(); }

String contextMenuItemTagGoBack()                                       { notImplemented(); return String(); }

String contextMenuItemTagCopy()                                         { notImplemented(); return String(); }

String contextMenuItemTagSearchWeb()                                    { notImplemented(); return String(); }

String contextMenuItemTagCopyImageToClipboard()                         { notImplemented(); return String(); }

String contextMenuItemTagDownloadImageToDisk()                          { notImplemented(); return String(); }

String contextMenuItemTagOpenImageInNewWindow()                         { notImplemented(); return String(); }

String contextMenuItemTagCopyLinkToClipboard()                          { notImplemented(); return String(); }

String contextMenuItemTagDownloadLinkToDisk()                           { notImplemented(); return String(); }

String contextMenuItemTagOpenLinkInNewWindow()                          { notImplemented(); return String(); }

String contextMenuItemTagOpenLink()                                     { notImplemented(); return String(); }

String contextMenuItemTagRightToLeft()                                  { notImplemented(); return String(); }

String contextMenuItemTagLeftToRight()                                  { notImplemented(); return String(); }

String contextMenuItemTagDefaultDirection()                             { notImplemented(); return String(); }

String contextMenuItemTagPaste()                                        { notImplemented(); return String(); }

String contextMenuItemTagIgnoreGrammar()                                { notImplemented(); return String(); }

String contextMenuItemTagIgnoreSpelling()                               { notImplemented(); return String(); }

String contextMenuItemTagReload()                                       { notImplemented(); return String(); }

String contextMenuItemTagLearnSpelling()                                { notImplemented(); return String(); }

String contextMenuItemTagCut()                                          { notImplemented(); return String(); }

String contextMenuItemTagWritingDirectionMenu()                         { notImplemented(); return String(); }

String contextMenuItemTagFontMenu()                                     { notImplemented(); return String(); }

String contextMenuItemTagInspectElement()                               { notImplemented(); return String(); }

String searchMenuNoRecentSearchesText()                                 { notImplemented(); return String(); }

String searchMenuRecentSearchesText()                                   { notImplemented(); return String(); }

String searchMenuClearRecentSearchesText()                              { notImplemented(); return String(); }

String unknownFileSizeText()                                            { notImplemented(); return String(); }

// Drag stuff

void* createDragImageFromImage(class Image *)                  { notImplemented(); return 0; }

void* dissolveDragImageToFraction(void *, float)               { notImplemented(); return 0; }

void* createDragImageIconForCachedImage(class CachedImage *)  { notImplemented(); return 0; }

DragImageRef scaleDragImage(DragImageRef, FloatSize )                   { notImplemented(); return 0; }

PlatformScrollbar* ScrollView::scrollbarUnderMouse(const PlatformMouseEvent &) { notImplemented(); return 0; }

// Frame

void Frame::setNeedsReapplyStyles()                                     { notImplemented(); }

// FrameView

void FrameView::updateBorder()                                          { notImplemented(); }

String DragData::asURL(WebCore::String*) const							{ notImplemented(); return String(); }

void DragData::asFilenames(Vector<String>&) const                       { notImplemented(); }

Clipboard* DragData::createClipboard(WebCore::ClipboardAccessPolicy) const	{ notImplemented(); return 0; }

String DragData::asPlainText() const									{ notImplemented(); return String(); }

bool DragData::canSmartReplace() const									{ notImplemented(); return false; }

Color DragData::asColor() const											{ notImplemented(); return Color(); }

bool DragData::containsColor() const									{ notImplemented(); return false; }

bool DragData::containsPlainText() const								{ notImplemented(); return false; }

bool DragData::containsURL() const										{ notImplemented(); return false; }

PassRefPtr<DocumentFragment> DragData::asFragment(WebCore::Document*) const	{ notImplemented(); return 0; }

bool DragData::containsCompatibleContent() const						{ notImplemented(); return false; }

bool DragData::containsFiles() const                                    { notImplemented(); return false; }

void ScrollView::wheelEvent(WebCore::PlatformWheelEvent&)				{ notImplemented(); }

void AffineTransform::map(double, double, double*, double*) const		{ notImplemented(); }

//Threading

void callOnMainThread(void (*)()) { notImplemented(); }

}