LayoutTests:
[WebKit-https.git] / WebCore / platform / graphics / svg / SVGImageEmptyClients.h
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 "SharedBuffer.h"
38
39 /*
40  This file holds empty Client stubs for use by SVGImage.
41  SVGImage needs to create a dummy Page->Frame->FrameView tree for use in parsing an SVGDocument.
42  This tree depends heavily on Clients (usually provided by WebKit classes).
43  
44  SVGImage has no way to access the current Page (nor should it, since Images are not tied to a page).
45  See http://bugs.webkit.org/show_bug.cgi?id=5971 for more discussion on this issue.
46  
47  Ideally, whenever you change a Client class, you should add a stub here.
48  Brittle, yes.  Unfortunate, yes.  Hopefully temporary.
49 */
50
51 namespace WebCore {
52
53 class SVGEmptyChromeClient : public ChromeClient {
54 public:
55     virtual ~SVGEmptyChromeClient() { }
56     virtual void chromeDestroyed() { }
57     
58     virtual void setWindowRect(const FloatRect&) { }
59     virtual FloatRect windowRect() { return FloatRect(); }
60     
61     virtual FloatRect pageRect() { return FloatRect(); }
62     
63     virtual float scaleFactor() { return 1.f; }
64     
65     virtual void focus() { }
66     virtual void unfocus() { }
67     
68     virtual bool canTakeFocus(FocusDirection) { return false; }
69     virtual void takeFocus(FocusDirection) { }
70     
71     virtual Page* createWindow(const FrameLoadRequest&) { return 0; }
72     virtual Page* createModalDialog(const FrameLoadRequest&) { return 0; }
73     virtual void show() { }
74     
75     virtual bool canRunModal() { return false; }
76     virtual void runModal() { }
77     
78     virtual void setToolbarsVisible(bool) { }
79     virtual bool toolbarsVisible() { return false; }
80     
81     virtual void setStatusbarVisible(bool) { }
82     virtual bool statusbarVisible() { return false; }
83     
84     virtual void setScrollbarsVisible(bool) { }
85     virtual bool scrollbarsVisible() { return false; }
86     
87     virtual void setMenubarVisible(bool) { }
88     virtual bool menubarVisible() { return false; }
89     
90     virtual void setResizable(bool) { }
91     
92     virtual void addMessageToConsole(const String& message, unsigned int lineNumber, const String& sourceID) { }
93     
94     virtual bool canRunBeforeUnloadConfirmPanel() { return false; }
95     virtual bool runBeforeUnloadConfirmPanel(const String& message, Frame* frame) { return true; }
96     
97     virtual void closeWindowSoon() { }
98     
99     virtual void runJavaScriptAlert(Frame*, const String&) { }
100     virtual bool runJavaScriptConfirm(Frame*, const String&) { return false; }
101     virtual bool runJavaScriptPrompt(Frame*, const String& message, const String& defaultValue, String& result) { return false; }
102     virtual bool shouldInterruptJavaScript() { return false; }
103     
104     virtual void setStatusbarText(const String&) { }
105     
106     virtual bool tabsToLinks() const { return false; }
107     
108     virtual IntRect windowResizerRect() const { return IntRect(); }
109     virtual void addToDirtyRegion(const IntRect&) { }
110     virtual void scrollBackingStore(int dx, int dy, const IntRect& scrollViewRect, const IntRect& clipRect) { }
111     virtual void updateBackingStore() { }
112     
113 };
114
115 class SVGEmptyFrameLoaderClient : public FrameLoaderClient {
116 public:
117     virtual ~SVGEmptyFrameLoaderClient() {  }
118     virtual void frameLoaderDestroyed() { }
119     
120     virtual bool hasWebView() const { return true; } // mainly for assertions
121     virtual bool hasFrameView() const { return true; } // ditto
122     
123     virtual bool hasBackForwardList() const { return false; }
124     virtual void resetBackForwardList() { }
125     
126     virtual bool provisionalItemIsTarget() const { return false; }
127     virtual bool loadProvisionalItemFromPageCache() { return false; }
128     virtual void invalidateCurrentItemPageCache() { }
129     
130     virtual bool privateBrowsingEnabled() const { return false; }
131     
132     virtual void makeDocumentView() { }
133     virtual void makeRepresentation(DocumentLoader*) { }
134     virtual void forceLayout() { }
135     virtual void forceLayoutForNonHTML() { }
136     
137     virtual void updateHistoryForCommit() { }
138     
139     virtual void updateHistoryForBackForwardNavigation() { }
140     virtual void updateHistoryForReload() { }
141     virtual void updateHistoryForStandardLoad() { }
142     virtual void updateHistoryForInternalLoad() { }
143     
144     virtual void updateHistoryAfterClientRedirect() { }
145     
146     virtual void setCopiesOnScroll() { }
147         
148     virtual void detachedFromParent2() { }
149     virtual void detachedFromParent3() { }
150     virtual void detachedFromParent4() { }
151     
152     virtual void loadedFromPageCache() { }
153     
154     virtual void download(ResourceHandle*, const ResourceRequest&, const ResourceResponse&) { }
155     
156     virtual void assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&) { }
157     virtual void dispatchWillSendRequest(DocumentLoader*, unsigned long identifier, ResourceRequest&, const ResourceResponse& redirectResponse) { }
158     virtual void dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&) { }
159     virtual void dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&) { }
160     virtual void dispatchDidReceiveResponse(DocumentLoader*, unsigned long identifier, const ResourceResponse&) { }
161     virtual void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long identifier, int lengthReceived) { }
162     virtual void dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier) { }
163     virtual void dispatchDidFailLoading(DocumentLoader*, unsigned long identifier, const ResourceError&) { }
164     virtual bool dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int length) { return false; }
165     
166     virtual void dispatchDidHandleOnloadEvents() { }
167     virtual void dispatchDidReceiveServerRedirectForProvisionalLoad() { }
168     virtual void dispatchDidCancelClientRedirect() { }
169     virtual void dispatchWillPerformClientRedirect(const KURL&, double interval, double fireDate) { }
170     virtual void dispatchDidChangeLocationWithinPage() { }
171     virtual void dispatchWillClose() { }
172     virtual void dispatchDidReceiveIcon() { }
173     virtual void dispatchDidStartProvisionalLoad() { }
174     virtual void dispatchDidReceiveTitle(const String& title) { }
175     virtual void dispatchDidCommitLoad() { }
176     virtual void dispatchDidFailProvisionalLoad(const ResourceError&) { }
177     virtual void dispatchDidFailLoad(const ResourceError&) { }
178     virtual void dispatchDidFinishDocumentLoad() { }
179     virtual void dispatchDidFinishLoad() { }
180     virtual void dispatchDidFirstLayout() { }
181     
182     virtual Frame* dispatchCreatePage() { return 0; }
183     virtual void dispatchShow() { }
184     
185     virtual void dispatchDecidePolicyForMIMEType(FramePolicyFunction, const String& MIMEType, const ResourceRequest&) { }
186     virtual void dispatchDecidePolicyForNewWindowAction(FramePolicyFunction, const NavigationAction&, const ResourceRequest&, const String& frameName) { }
187     virtual void dispatchDecidePolicyForNavigationAction(FramePolicyFunction, const NavigationAction&, const ResourceRequest&) { }
188     virtual void cancelPolicyCheck() { }
189     
190     virtual void dispatchUnableToImplementPolicy(const ResourceError&) { }
191
192     virtual void dispatchWillSubmitForm(FramePolicyFunction, PassRefPtr<FormState>) { }
193     
194     virtual void dispatchDidLoadMainResource(DocumentLoader*) { }
195     virtual void clearLoadingFromPageCache(DocumentLoader*) { }
196     virtual bool isLoadingFromPageCache(DocumentLoader*) { return 0; }
197     virtual void revertToProvisionalState(DocumentLoader*) { }
198     virtual void setMainDocumentError(DocumentLoader*, const ResourceError&) { }
199     virtual void clearUnarchivingState(DocumentLoader*) { }
200     
201     virtual void willChangeEstimatedProgress() { }
202     virtual void didChangeEstimatedProgress() { }
203     virtual void postProgressStartedNotification() { }
204     virtual void postProgressEstimateChangedNotification() { }
205     virtual void postProgressFinishedNotification() { }
206     
207     virtual void setMainFrameDocumentReady(bool) { }
208     
209     virtual void startDownload(const ResourceRequest&) { }
210     
211     virtual void willChangeTitle(DocumentLoader*) { }
212     virtual void didChangeTitle(DocumentLoader*) { }
213     
214     virtual void committedLoad(DocumentLoader*, const char*, int) { }
215     virtual void finishedLoading(DocumentLoader*) { }
216     virtual void finalSetupForReplace(DocumentLoader*) { }
217     
218     virtual ResourceError cancelledError(const ResourceRequest&) { return ResourceError(); }
219     virtual ResourceError blockedError(const ResourceRequest&) { return ResourceError(); }
220     virtual ResourceError cannotShowURLError(const ResourceRequest&) { return ResourceError(); }
221     virtual ResourceError interruptForPolicyChangeError(const ResourceRequest&) { return ResourceError(); }
222     
223     virtual ResourceError cannotShowMIMETypeError(const ResourceResponse&) { return ResourceError(); }
224     virtual ResourceError fileDoesNotExistError(const ResourceResponse&) { return ResourceError(); }
225     
226     virtual bool shouldFallBack(const ResourceError&) { return false; }
227     
228     virtual void setDefersLoading(bool) { }
229     
230     virtual bool willUseArchive(ResourceLoader*, const ResourceRequest&, const KURL& originalURL) const { return false; }
231     virtual bool isArchiveLoadPending(ResourceLoader*) const { return false; }
232     virtual void cancelPendingArchiveLoad(ResourceLoader*) { }
233     virtual void clearArchivedResources() { }
234     
235     virtual bool canHandleRequest(const ResourceRequest&) const { return false; }
236     virtual bool canShowMIMEType(const String& MIMEType) const { return false; }
237     virtual bool representationExistsForURLScheme(const String& URLScheme) const { return false; }
238     virtual String generatedMIMETypeForURLScheme(const String& URLScheme) const { return ""; }
239     
240     virtual void frameLoadCompleted() { }
241     virtual void restoreViewState() { }
242     virtual void provisionalLoadStarted() { }
243     virtual bool shouldTreatURLAsSameAsCurrent(const KURL&) const { return false; }
244     virtual void addHistoryItemForFragmentScroll() { }
245     virtual void didFinishLoad() { }
246     virtual void prepareForDataSourceReplacement() { }
247     
248     virtual PassRefPtr<DocumentLoader> createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData) { return new DocumentLoader(request, substituteData); }
249     virtual void setTitle(const String& title, const KURL&) { }
250     
251     virtual String userAgent(const KURL&) { return ""; }
252     
253     virtual void setDocumentViewFromPageCache(PageCache*) { }
254     virtual void updateGlobalHistoryForStandardLoad(const KURL&) { }
255     virtual void updateGlobalHistoryForReload(const KURL&) { }
256     virtual bool shouldGoToHistoryItem(HistoryItem*) const { return false; }
257     virtual void saveViewStateToItem(HistoryItem*) { }
258     virtual void saveDocumentViewToPageCache(PageCache*) { }
259     virtual bool canCachePage() const { return false; }
260
261     virtual Frame* createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
262                                const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight) { return 0; }
263     virtual Widget* createPlugin(Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool) { return 0; }
264     virtual Widget* createJavaAppletWidget(const IntSize&, Element*, const KURL&, const Vector<String>&, const Vector<String>&) { return 0; }
265     
266     virtual ObjectContentType objectContentType(const KURL& url, const String& mimeType) { return ObjectContentType(); }
267     virtual String overrideMediaType() const { return String(); }
268
269     virtual void redirectDataToPlugin(WebCore::Widget*) {}
270     virtual void windowObjectCleared() const {}
271 };
272
273 class SVGEmptyEditorClient : public EditorClient {
274 public:
275     virtual ~SVGEmptyEditorClient() { }
276     virtual void pageDestroyed() { }
277     
278     virtual bool shouldDeleteRange(Range*) { return false; }
279     virtual bool shouldShowDeleteInterface(HTMLElement*) { return false; }
280     virtual bool smartInsertDeleteEnabled() { return false; } 
281     virtual bool isContinuousSpellCheckingEnabled() { return false; }
282     virtual void toggleContinuousSpellChecking() { }
283     virtual bool isGrammarCheckingEnabled() { return false; }
284     virtual void toggleGrammarChecking() { }
285     virtual int spellCheckerDocumentTag() { return -1; }
286     
287     virtual bool selectWordBeforeMenuEvent() { return false; }
288     virtual bool isEditable() { return false; }
289     
290     virtual bool shouldBeginEditing(Range*) { return false; }
291     virtual bool shouldEndEditing(Range*) { return false; }
292     virtual bool shouldInsertNode(Node*, Range*, EditorInsertAction) { return false; }
293     //  virtual bool shouldInsertNode(Node*, Range* replacingRange, WebViewInsertAction) { return false; }
294     virtual bool shouldInsertText(String, Range*, EditorInsertAction) { return false; }
295     virtual bool shouldChangeSelectedRange(Range* fromRange, Range* toRange, EAffinity, bool stillSelecting) { return false; }
296
297     virtual bool shouldApplyStyle(CSSStyleDeclaration*, Range*) { return false; }
298     //  virtual bool shouldChangeTypingStyle(CSSStyleDeclaration* fromStyle, CSSStyleDeclaration* toStyle) { return false; }
299     //  virtual bool doCommandBySelector(SEL selector) { return false; }
300     //
301     virtual void didBeginEditing() { }
302     virtual void respondToChangedContents() { }
303     virtual void respondToChangedSelection() { }
304     virtual void didEndEditing() { }
305     virtual void didWriteSelectionToPasteboard() { }
306     virtual void didSetSelectionTypesForPasteboard() { }
307     //  virtual void webViewDidChangeTypingStyle:(NSNotification *)notification { }
308     //  virtual void webViewDidChangeSelection:(NSNotification *)notification { }
309     //  virtual NSUndoManager* undoManagerForWebView:(WebView *)webView { return 0; }
310     
311     virtual void registerCommandForUndo(PassRefPtr<EditCommand>) { }
312     virtual void registerCommandForRedo(PassRefPtr<EditCommand>) { }
313     virtual void clearUndoRedoOperations() { }
314     
315     virtual bool canUndo() const { return false; }
316     virtual bool canRedo() const { return false; }
317     
318     virtual void undo() { }
319     virtual void redo() { }
320
321     virtual void handleKeypress(KeyboardEvent*) { }
322     virtual void handleInputMethodKeypress(KeyboardEvent*) { }
323
324     virtual void textFieldDidBeginEditing(Element*) { }
325     virtual void textFieldDidEndEditing(Element*) { }
326     virtual void textDidChangeInTextField(Element*) { }
327     virtual bool doTextFieldCommandFromEvent(Element*, KeyboardEvent*) { return false; }
328     virtual void textWillBeDeletedInTextField(Element*) { }
329     virtual void textDidChangeInTextArea(Element*) { }
330     
331 #if PLATFORM(MAC)
332     virtual void markedTextAbandoned(Frame*) { }
333
334     // FIXME: This should become SelectionController::toWebArchive()
335     virtual NSData* dataForArchivedSelection(Frame*) { return 0; } 
336     
337     virtual NSString* userVisibleString(NSURL*) { return 0; }
338 #ifdef BUILDING_ON_TIGER
339     virtual NSArray* pasteboardTypesForSelection(Frame*) { return 0; }
340 #endif
341 #endif
342   
343     
344 };
345
346 class SVGEmptyContextMenuClient : public ContextMenuClient {
347 public:
348     virtual ~SVGEmptyContextMenuClient() {  }
349     virtual void contextMenuDestroyed() { }
350     
351     virtual PlatformMenuDescription getCustomMenuFromDefaultItems(ContextMenu*) { return 0; }
352     virtual void contextMenuItemSelected(ContextMenuItem*, const ContextMenu*) { }
353     
354     virtual void downloadURL(const KURL& url) { }
355     virtual void copyImageToClipboard(const HitTestResult&) { }
356     virtual void searchWithGoogle(const Frame*) { }
357     virtual void lookUpInDictionary(Frame*) { }
358     virtual void speak(const String&) { }
359     virtual void stopSpeaking() { }
360     
361 #if PLATFORM(MAC)
362     virtual void searchWithSpotlight() { }
363 #endif
364 };
365
366 class SVGEmptyDragClient : public DragClient {
367 public:
368     virtual ~SVGEmptyDragClient() {}
369     virtual void willPerformDragDestinationAction(DragDestinationAction, DragData*) { }
370     virtual void willPerformDragSourceAction(DragSourceAction, const IntPoint&, Clipboard*) { }
371     virtual DragDestinationAction actionMaskForDrag(DragData*) { return DragDestinationActionNone; }
372     virtual DragSourceAction dragSourceActionMaskForPoint(const IntPoint&) { return DragSourceActionNone; }
373     virtual void startDrag(DragImageRef, const IntPoint&, const IntPoint&, Clipboard*, Frame*, bool) { }
374     virtual DragImageRef createDragImageForLink(KURL&, const String& label, Frame*) { return 0; } 
375     virtual void dragControllerDestroyed() { }
376 };
377     
378 }
379
380 #endif // ENABLE(SVG)
381
382 #endif // SVGImageEmptyClients_h
383