1 /*

     2  * Copyright (C) 2006 Eric Seidel (eric@webkit.org)

     3  *

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

     5  * modification, are permitted provided that the following conditions

     6  * are met:

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

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

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

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

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

    12  *

    13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

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

    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

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

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

    24  */

    25 

    26 #ifndef SVGImageEmptyClients_h

    27 #define SVGImageEmptyClients_h

    28 

    29 #if ENABLE(SVG)

    30 

    31 #include "ChromeClient.h"

    32 #include "ContextMenuClient.h"

    33 #include "DragClient.h"

    34 #include "EditorClient.h"

    35 #include "FocusDirection.h"

    36 #include "FrameLoaderClient.h"

    37 #include "InspectorClient.h"

    38 #include "SharedBuffer.h"

    39 

    40 /*

    41  This file holds empty Client stubs for use by SVGImage.

    42  SVGImage needs to create a dummy Page->Frame->FrameView tree for use in parsing an SVGDocument.

    43  This tree depends heavily on Clients (usually provided by WebKit classes).

    44 

    45  SVGImage has no way to access the current Page (nor should it, since Images are not tied to a page).

    46  See http://bugs.webkit.org/show_bug.cgi?id=5971 for more discussion on this issue.

    47 

    48  Ideally, whenever you change a Client class, you should add a stub here.

    49  Brittle, yes.  Unfortunate, yes.  Hopefully temporary.

    50 */

    51 

    52 namespace WebCore {

    53 

    54 class SVGEmptyChromeClient : public ChromeClient {

    55 public:

    56     virtual ~SVGEmptyChromeClient() { }

    57     virtual void chromeDestroyed() { }

    58 

    59     virtual void setWindowRect(const FloatRect&) { }

    60     virtual FloatRect windowRect() { return FloatRect(); }

    61 

    62     virtual FloatRect pageRect() { return FloatRect(); }

    63 

    64     virtual float scaleFactor() { return 1.f; }

    65 

    66     virtual void focus() { }

    67     virtual void unfocus() { }

    68 

    69     virtual bool canTakeFocus(FocusDirection) { return false; }

    70     virtual void takeFocus(FocusDirection) { }

    71 

    72     virtual Page* createWindow(Frame*, const FrameLoadRequest&) { return 0; }

    73     virtual Page* createModalDialog(Frame*, const FrameLoadRequest&) { return 0; }

    74     virtual void show() { }

    75 

    76     virtual bool canRunModal() { return false; }

    77     virtual void runModal() { }

    78 

    79     virtual void setToolbarsVisible(bool) { }

    80     virtual bool toolbarsVisible() { return false; }

    81 

    82     virtual void setStatusbarVisible(bool) { }

    83     virtual bool statusbarVisible() { return false; }

    84 

    85     virtual void setScrollbarsVisible(bool) { }

    86     virtual bool scrollbarsVisible() { return false; }

    87 

    88     virtual void setMenubarVisible(bool) { }

    89     virtual bool menubarVisible() { return false; }

    90 

    91     virtual void setResizable(bool) { }

    92 

    93     virtual void addMessageToConsole(const String& message, MessageLevel messageLevel, unsigned int lineNumber, const String& sourceID) { }

    94 

    95     virtual bool canRunBeforeUnloadConfirmPanel() { return false; }

    96     virtual bool runBeforeUnloadConfirmPanel(const String& message, Frame* frame) { return true; }

    97 

    98     virtual void closeWindowSoon() { }

    99 

   100     virtual void runJavaScriptAlert(Frame*, const String&) { }

   101     virtual bool runJavaScriptConfirm(Frame*, const String&) { return false; }

   102     virtual bool runJavaScriptPrompt(Frame*, const String& message, const String& defaultValue, String& result) { return false; }

   103     virtual bool shouldInterruptJavaScript() { return false; }

   104 

   105     virtual void setStatusbarText(const String&) { }

   106 

   107     virtual bool tabsToLinks() const { return false; }

   108 

   109     virtual IntRect windowResizerRect() const { return IntRect(); }

   110     virtual void addToDirtyRegion(const IntRect&) { }

   111     virtual void scrollBackingStore(int dx, int dy, const IntRect& scrollViewRect, const IntRect& clipRect) { }

   112     virtual void updateBackingStore() { }

   113 

   114     virtual void mouseDidMoveOverElement(const HitTestResult&, unsigned modifierFlags) { }

   115 

   116     virtual void setToolTip(const String&) { }

   117 

   118     virtual void print(Frame*) { }

   119 };

   120 

   121 class SVGEmptyFrameLoaderClient : public FrameLoaderClient {

   122 public:

   123     virtual ~SVGEmptyFrameLoaderClient() {  }

   124     virtual void frameLoaderDestroyed() { }

   125 

   126     virtual bool hasWebView() const { return true; } // mainly for assertions

   127     virtual bool hasFrameView() const { return true; } // ditto

   128 

   129     virtual bool hasBackForwardList() const { return false; }

   130     virtual void resetBackForwardList() { }

   131 

   132     virtual bool provisionalItemIsTarget() const { return false; }

   133     virtual bool loadProvisionalItemFromCachedPage() { return false; }

   134     virtual void invalidateCurrentItemCachedPage() { }

   135 

   136     virtual bool privateBrowsingEnabled() const { return false; }

   137 

   138     virtual void makeDocumentView() { }

   139     virtual void makeRepresentation(DocumentLoader*) { }

   140     virtual void forceLayout() { }

   141     virtual void forceLayoutForNonHTML() { }

   142 

   143     virtual void updateHistoryForCommit() { }

   144 

   145     virtual void updateHistoryForBackForwardNavigation() { }

   146     virtual void updateHistoryForReload() { }

   147     virtual void updateHistoryForStandardLoad() { }

   148     virtual void updateHistoryForInternalLoad() { }

   149 

   150     virtual void updateHistoryAfterClientRedirect() { }

   151 

   152     virtual void setCopiesOnScroll() { }

   153 

   154     virtual void detachedFromParent2() { }

   155     virtual void detachedFromParent3() { }

   156     virtual void detachedFromParent4() { }

   157 

   158     virtual void download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&) { }

   159 

   160     virtual void assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&) { }

   161     virtual void dispatchWillSendRequest(DocumentLoader*, unsigned long identifier, ResourceRequest&, const ResourceResponse& redirectResponse) { }

   162     virtual void dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&) { }

   163     virtual void dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&) { }

   164     virtual void dispatchDidReceiveResponse(DocumentLoader*, unsigned long identifier, const ResourceResponse&) { }

   165     virtual void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long identifier, int lengthReceived) { }

   166     virtual void dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier) { }

   167     virtual void dispatchDidFailLoading(DocumentLoader*, unsigned long identifier, const ResourceError&) { }

   168     virtual bool dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int length) { return false; }

   169 

   170     virtual void dispatchDidHandleOnloadEvents() { }

   171     virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() { }

   172     virtual void dispatchDidCancelClientRedirect() { }

   173     virtual void dispatchWillPerformClientRedirect(const KURL&, double interval, double fireDate) { }

   174     virtual void dispatchDidChangeLocationWithinPage() { }

   175     virtual void dispatchWillClose() { }

   176     virtual void dispatchDidReceiveIcon() { }

   177     virtual void dispatchDidStartProvisionalLoad() { }

   178     virtual void dispatchDidReceiveTitle(const String& title) { }

   179     virtual void dispatchDidCommitLoad() { }

   180     virtual void dispatchDidFailProvisionalLoad(const ResourceError&) { }

   181     virtual void dispatchDidFailLoad(const ResourceError&) { }

   182     virtual void dispatchDidFinishDocumentLoad() { }

   183     virtual void dispatchDidFinishLoad() { }

   184     virtual void dispatchDidFirstLayout() { }

   185 

   186     virtual Frame* dispatchCreatePage() { return 0; }

   187     virtual void dispatchShow() { }

   188 

   189     virtual void dispatchDecidePolicyForMIMEType(FramePolicyFunction, const String& MIMEType, const ResourceRequest&) { }

   190     virtual void dispatchDecidePolicyForNewWindowAction(FramePolicyFunction, const NavigationAction&, const ResourceRequest&, const String& frameName) { }

   191     virtual void dispatchDecidePolicyForNavigationAction(FramePolicyFunction, const NavigationAction&, const ResourceRequest&) { }

   192     virtual void cancelPolicyCheck() { }

   193 

   194     virtual void dispatchUnableToImplementPolicy(const ResourceError&) { }

   195 

   196     virtual void dispatchWillSubmitForm(FramePolicyFunction, PassRefPtr<FormState>) { }

   197 

   198     virtual void dispatchDidLoadMainResource(DocumentLoader*) { }

   199     virtual void clearLoadingFromCachedPage(DocumentLoader*) { }

   200     virtual bool isLoadingFromCachedPage(DocumentLoader*) { return 0; }

   201     virtual void revertToProvisionalState(DocumentLoader*) { }

   202     virtual void setMainDocumentError(DocumentLoader*, const ResourceError&) { }

   203     virtual void clearUnarchivingState(DocumentLoader*) { }

   204 

   205     virtual void willChangeEstimatedProgress() { }

   206     virtual void didChangeEstimatedProgress() { }

   207     virtual void postProgressStartedNotification() { }

   208     virtual void postProgressEstimateChangedNotification() { }

   209     virtual void postProgressFinishedNotification() { }

   210 

   211     virtual void setMainFrameDocumentReady(bool) { }

   212 

   213     virtual void startDownload(const ResourceRequest&) { }

   214 

   215     virtual void willChangeTitle(DocumentLoader*) { }

   216     virtual void didChangeTitle(DocumentLoader*) { }

   217 

   218     virtual void committedLoad(DocumentLoader*, const char*, int) { }

   219     virtual void finishedLoading(DocumentLoader*) { }

   220     virtual void finalSetupForReplace(DocumentLoader*) { }

   221 

   222     virtual ResourceError cancelledError(const ResourceRequest&) { return ResourceError(); }

   223     virtual ResourceError blockedError(const ResourceRequest&) { return ResourceError(); }

   224     virtual ResourceError cannotShowURLError(const ResourceRequest&) { return ResourceError(); }

   225     virtual ResourceError interruptForPolicyChangeError(const ResourceRequest&) { return ResourceError(); }

   226 

   227     virtual ResourceError cannotShowMIMETypeError(const ResourceResponse&) { return ResourceError(); }

   228     virtual ResourceError fileDoesNotExistError(const ResourceResponse&) { return ResourceError(); }

   229 

   230     virtual bool shouldFallBack(const ResourceError&) { return false; }

   231 

   232     virtual void setDefersLoading(bool) { }

   233 

   234     virtual bool willUseArchive(ResourceLoader*, const ResourceRequest&, const KURL& originalURL) const { return false; }

   235     virtual bool isArchiveLoadPending(ResourceLoader*) const { return false; }

   236     virtual void cancelPendingArchiveLoad(ResourceLoader*) { }

   237     virtual void clearArchivedResources() { }

   238 

   239     virtual bool canHandleRequest(const ResourceRequest&) const { return false; }

   240     virtual bool canShowMIMEType(const String& MIMEType) const { return false; }

   241     virtual bool representationExistsForURLScheme(const String& URLScheme) const { return false; }

   242     virtual String generatedMIMETypeForURLScheme(const String& URLScheme) const { return ""; }

   243 

   244     virtual void frameLoadCompleted() { }

   245     virtual void restoreViewState() { }

   246     virtual void provisionalLoadStarted() { }

   247     virtual bool shouldTreatURLAsSameAsCurrent(const KURL&) const { return false; }

   248     virtual void addHistoryItemForFragmentScroll() { }

   249     virtual void didFinishLoad() { }

   250     virtual void prepareForDataSourceReplacement() { }

   251 

   252     virtual PassRefPtr<DocumentLoader> createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData) { return new DocumentLoader(request, substituteData); }

   253     virtual void setTitle(const String& title, const KURL&) { }

   254 

   255     virtual String userAgent(const KURL&) { return ""; }

   256 

   257     virtual void setDocumentViewFromCachedPage(CachedPage*) { }

   258     virtual void updateGlobalHistoryForStandardLoad(const KURL&) { }

   259     virtual void updateGlobalHistoryForReload(const KURL&) { }

   260     virtual bool shouldGoToHistoryItem(HistoryItem*) const { return false; }

   261     virtual void saveViewStateToItem(HistoryItem*) { }

   262     virtual void saveDocumentViewToCachedPage(CachedPage*) { }

   263     virtual bool canCachePage() const { return false; }

   264 

   265     virtual PassRefPtr<Frame> createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,

   266                                const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight) { return 0; }

   267     virtual Widget* createPlugin(const IntSize&,Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool) { return 0; }

   268     virtual Widget* createJavaAppletWidget(const IntSize&, Element*, const KURL&, const Vector<String>&, const Vector<String>&) { return 0; }

   269 

   270     virtual ObjectContentType objectContentType(const KURL& url, const String& mimeType) { return ObjectContentType(); }

   271     virtual String overrideMediaType() const { return String(); }

   272 

   273     virtual void redirectDataToPlugin(WebCore::Widget*) {}

   274     virtual void windowObjectCleared() const {}

   275     virtual void didPerformFirstNavigation() const {}

   276 

   277     virtual void registerForIconNotification(bool listen) {}

   278 

   279 #if PLATFORM(MAC)

   280     virtual NSCachedURLResponse* willCacheResponse(DocumentLoader*, unsigned long identifier, NSCachedURLResponse* response) const { return response; }

   281 #endif

   282 

   283 };

   284 

   285 class SVGEmptyEditorClient : public EditorClient {

   286 public:

   287     virtual ~SVGEmptyEditorClient() { }

   288     virtual void pageDestroyed() { }

   289 

   290     virtual bool shouldDeleteRange(Range*) { return false; }

   291     virtual bool shouldShowDeleteInterface(HTMLElement*) { return false; }

   292     virtual bool smartInsertDeleteEnabled() { return false; }

   293     virtual bool isContinuousSpellCheckingEnabled() { return false; }

   294     virtual void toggleContinuousSpellChecking() { }

   295     virtual bool isGrammarCheckingEnabled() { return false; }

   296     virtual void toggleGrammarChecking() { }

   297     virtual int spellCheckerDocumentTag() { return -1; }

   298 

   299     virtual bool selectWordBeforeMenuEvent() { return false; }

   300     virtual bool isEditable() { return false; }

   301 

   302     virtual bool shouldBeginEditing(Range*) { return false; }

   303     virtual bool shouldEndEditing(Range*) { return false; }

   304     virtual bool shouldInsertNode(Node*, Range*, EditorInsertAction) { return false; }

   305     //  virtual bool shouldInsertNode(Node*, Range* replacingRange, WebViewInsertAction) { return false; }

   306     virtual bool shouldInsertText(String, Range*, EditorInsertAction) { return false; }

   307     virtual bool shouldChangeSelectedRange(Range* fromRange, Range* toRange, EAffinity, bool stillSelecting) { return false; }

   308 

   309     virtual bool shouldApplyStyle(CSSStyleDeclaration*, Range*) { return false; }

   310     virtual bool shouldMoveRangeAfterDelete(Range*, Range*) { return false; }

   311     //  virtual bool shouldChangeTypingStyle(CSSStyleDeclaration* fromStyle, CSSStyleDeclaration* toStyle) { return false; }

   312     //  virtual bool doCommandBySelector(SEL selector) { return false; }

   313     //

   314     virtual void didBeginEditing() { }

   315     virtual void respondToChangedContents() { }

   316     virtual void respondToChangedSelection() { }

   317     virtual void didEndEditing() { }

   318     virtual void didWriteSelectionToPasteboard() { }

   319     virtual void didSetSelectionTypesForPasteboard() { }

   320     //  virtual void webViewDidChangeTypingStyle:(NSNotification *)notification { }

   321     //  virtual void webViewDidChangeSelection:(NSNotification *)notification { }

   322     //  virtual NSUndoManager* undoManagerForWebView:(WebView *)webView { return 0; }

   323 

   324     virtual void registerCommandForUndo(PassRefPtr<EditCommand>) { }

   325     virtual void registerCommandForRedo(PassRefPtr<EditCommand>) { }

   326     virtual void clearUndoRedoOperations() { }

   327 

   328     virtual bool canUndo() const { return false; }

   329     virtual bool canRedo() const { return false; }

   330 

   331     virtual void undo() { }

   332     virtual void redo() { }

   333 

   334     virtual void handleKeypress(KeyboardEvent*) { }

   335     virtual void handleInputMethodKeypress(KeyboardEvent*) { }

   336 

   337     virtual void textFieldDidBeginEditing(Element*) { }

   338     virtual void textFieldDidEndEditing(Element*) { }

   339     virtual void textDidChangeInTextField(Element*) { }

   340     virtual bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*) { return false; }

   341     virtual void textWillBeDeletedInTextField(Element*) { }

   342     virtual void textDidChangeInTextArea(Element*) { }

   343 

   344 #if PLATFORM(MAC)

   345     virtual void markedTextAbandoned(Frame*) { }

   346 

   347     // FIXME: This should become SelectionController::toWebArchive()

   348     virtual NSData* dataForArchivedSelection(Frame*) { return 0; }

   349 

   350     virtual NSString* userVisibleString(NSURL*) { return 0; }

   351 #ifdef BUILDING_ON_TIGER

   352     virtual NSArray* pasteboardTypesForSelection(Frame*) { return 0; }

   353 #endif

   354 #endif

   355     virtual void ignoreWordInSpellDocument(const String&) { }

   356     virtual void learnWord(const String&) { }

   357     virtual void checkSpellingOfString(const UChar*, int length, int* misspellingLocation, int* misspellingLength) { }

   358     virtual void checkGrammarOfString(const UChar*, int length, Vector<GrammarDetail>&, int* badGrammarLocation, int* badGrammarLength) { }

   359     virtual void updateSpellingUIWithGrammarString(const String&, const GrammarDetail&) { }

   360     virtual void updateSpellingUIWithMisspelledWord(const String&) { }

   361     virtual void showSpellingUI(bool show) { }

   362     virtual bool spellingUIIsShowing() { return false; }

   363     virtual void getGuessesForWord(const String&, Vector<String>& guesses) { }

   364     virtual void setInputMethodState(bool enabled) { }

   365 

   366 

   367 };

   368 

   369 class SVGEmptyContextMenuClient : public ContextMenuClient {

   370 public:

   371     virtual ~SVGEmptyContextMenuClient() {  }

   372     virtual void contextMenuDestroyed() { }

   373 

   374     virtual PlatformMenuDescription getCustomMenuFromDefaultItems(ContextMenu*) { return 0; }

   375     virtual void contextMenuItemSelected(ContextMenuItem*, const ContextMenu*) { }

   376 

   377     virtual void downloadURL(const KURL& url) { }

   378     virtual void copyImageToClipboard(const HitTestResult&) { }

   379     virtual void searchWithGoogle(const Frame*) { }

   380     virtual void lookUpInDictionary(Frame*) { }

   381     virtual void speak(const String&) { }

   382     virtual void stopSpeaking() { }

   383 

   384 #if PLATFORM(MAC)

   385     virtual void searchWithSpotlight() { }

   386 #endif

   387 };

   388 

   389 class SVGEmptyDragClient : public DragClient {

   390 public:

   391     virtual ~SVGEmptyDragClient() {}

   392     virtual void willPerformDragDestinationAction(DragDestinationAction, DragData*) { }

   393     virtual void willPerformDragSourceAction(DragSourceAction, const IntPoint&, Clipboard*) { }

   394     virtual DragDestinationAction actionMaskForDrag(DragData*) { return DragDestinationActionNone; }

   395     virtual DragSourceAction dragSourceActionMaskForPoint(const IntPoint&) { return DragSourceActionNone; }

   396     virtual void startDrag(DragImageRef, const IntPoint&, const IntPoint&, Clipboard*, Frame*, bool) { }

   397     virtual DragImageRef createDragImageForLink(KURL&, const String& label, Frame*) { return 0; }

   398     virtual void dragControllerDestroyed() { }

   399 };

   400 

   401 class SVGEmptyInspectorClient : public InspectorClient {

   402 public:

   403     virtual ~SVGEmptyInspectorClient() {}

   404 

   405     virtual void inspectorDestroyed() {};

   406 

   407     virtual WebCore::Page* createPage() { return 0; };

   408 

   409     virtual void showWindow() {};

   410     virtual void closeWindow() {};

   411 

   412     virtual void attachWindow() {};

   413     virtual void detachWindow() {};

   414 

   415     virtual void highlight(WebCore::Node*) {};

   416     virtual void hideHighlight() {};

   417     virtual void inspectedURLChanged(const WebCore::String& newURL) {};

   418 };

   419 

   420 }

   421 

   422 #endif // ENABLE(SVG)

   423 

   424 #endif // SVGImageEmptyClients_h

   425