990e5f4d6fe665de6a30ef167a73eb4c3e86edf9
[WebKit-https.git] / WebKit / gtk / WebView / webkitwebframe.cpp
1 /*
2  * Copyright (C) 2007 Holger Hans Peter Freyther
3  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
4  * Copyright (C) 2007 Apple Inc.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  */
21
22 #include "config.h"
23
24 #include "webkitwebframe.h"
25 #include "webkitwebview.h"
26 #include "webkit-marshal.h"
27 #include "webkitprivate.h"
28
29 #include "CString.h"
30 #include "FrameLoader.h"
31 #include "FrameLoaderClientGtk.h"
32 #include "FrameTree.h"
33 #include "FrameView.h"
34 #include "GraphicsContext.h"
35 #include "HTMLFrameOwnerElement.h"
36 #include "RenderView.h"
37 #include "kjs_binding.h"
38 #include "kjs_proxy.h"
39 #include "kjs_window.h"
40
41 #include <JavaScriptCore/APICast.h>
42
43 using namespace WebKit;
44 using namespace WebCore;
45
46 extern "C" {
47
48 enum {
49     CLEARED,
50     LOAD_COMMITTED,
51     LOAD_DONE,
52     TITLE_CHANGED,
53     HOVERING_OVER_LINK,
54     LAST_SIGNAL
55 };
56
57 static guint webkit_web_frame_signals[LAST_SIGNAL] = { 0, };
58
59 G_DEFINE_TYPE(WebKitWebFrame, webkit_web_frame, G_TYPE_OBJECT)
60
61 static void webkit_web_frame_finalize(GObject* object)
62 {
63     WebKitWebFramePrivate* privateData = WEBKIT_WEB_FRAME_GET_PRIVATE(WEBKIT_WEB_FRAME(object));
64     privateData->frame->loader()->cancelAndClear();
65     g_free(privateData->name);
66     g_free(privateData->title);
67     g_free(privateData->uri);
68     delete privateData->frame;
69
70     G_OBJECT_CLASS(webkit_web_frame_parent_class)->finalize(object);
71 }
72
73 static void webkit_web_frame_class_init(WebKitWebFrameClass* frameClass)
74 {
75     webkit_init();
76
77     g_type_class_add_private(frameClass, sizeof(WebKitWebFramePrivate));
78
79     /*
80      * signals
81      */
82     webkit_web_frame_signals[CLEARED] = g_signal_new("cleared",
83             G_TYPE_FROM_CLASS(frameClass),
84             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
85             0,
86             NULL,
87             NULL,
88             g_cclosure_marshal_VOID__VOID,
89             G_TYPE_NONE, 0);
90
91     webkit_web_frame_signals[LOAD_COMMITTED] = g_signal_new("load-committed",
92             G_TYPE_FROM_CLASS(frameClass),
93             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
94             0,
95             NULL,
96             NULL,
97             g_cclosure_marshal_VOID__VOID,
98             G_TYPE_NONE, 0);
99
100     webkit_web_frame_signals[LOAD_DONE] = g_signal_new("load-done",
101             G_TYPE_FROM_CLASS(frameClass),
102             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
103             0,
104             NULL,
105             NULL,
106             g_cclosure_marshal_VOID__BOOLEAN,
107             G_TYPE_NONE, 1,
108             G_TYPE_BOOLEAN);
109
110     webkit_web_frame_signals[TITLE_CHANGED] = g_signal_new("title-changed",
111             G_TYPE_FROM_CLASS(frameClass),
112             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
113             0,                                               
114             NULL,
115             NULL,
116             webkit_marshal_VOID__STRING,
117             G_TYPE_NONE, 1,
118             G_TYPE_STRING);
119
120     webkit_web_frame_signals[HOVERING_OVER_LINK] = g_signal_new("hovering-over-link",
121             G_TYPE_FROM_CLASS(frameClass),
122             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
123             0,
124             NULL,
125             NULL,
126             webkit_marshal_VOID__STRING_STRING,
127             G_TYPE_NONE, 2,
128             G_TYPE_STRING, G_TYPE_STRING);
129
130     /*
131      * implementations of virtual methods
132      */
133     G_OBJECT_CLASS(frameClass)->finalize = webkit_web_frame_finalize;
134 }
135
136 static void webkit_web_frame_init(WebKitWebFrame* frame)
137 {
138     // TODO: Move constructor code here.
139 }
140
141 /**
142  * webkit_web_frame_new:
143  * @web_view: the controlling #WebKitWebView
144  *
145  * Creates a new #WebKitWebFrame initialized with a controlling #WebKitWebView.
146  *
147  * Returns: a new #WebKitWebFrame
148  **/
149 WebKitWebFrame* webkit_web_frame_new(WebKitWebView* webView)
150 {
151     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL);
152
153     WebKitWebFrame* frame = WEBKIT_WEB_FRAME(g_object_new(WEBKIT_TYPE_WEB_FRAME, NULL));
154     WebKitWebFramePrivate* frameData = WEBKIT_WEB_FRAME_GET_PRIVATE(frame);
155     WebKitWebViewPrivate* webViewData = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);
156
157     frameData->client = new WebKit::FrameLoaderClient(frame);
158     frameData->frame = new Frame(webViewData->corePage, 0, frameData->client);
159
160     FrameView* frameView = new FrameView(frameData->frame);
161     frameView->setContainingWindow(GTK_CONTAINER(webView));
162     frameView->setGtkAdjustments(GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)),
163                                  GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)));
164     frameData->frame->setView(frameView);
165     frameData->frame->init();
166     frameData->webView = webView;
167     frameData->name = 0;
168     frameData->title = 0;
169     frameData->uri = 0;
170
171     return frame;
172 }
173
174 WebKitWebFrame* webkit_web_frame_init_with_web_view(WebKitWebView* webView, HTMLFrameOwnerElement* element)
175 {
176     WebKitWebFrame* frame = WEBKIT_WEB_FRAME(g_object_new(WEBKIT_TYPE_WEB_FRAME, NULL));
177     WebKitWebFramePrivate* frameData = WEBKIT_WEB_FRAME_GET_PRIVATE(frame);
178     WebKitWebViewPrivate* webViewData = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);
179
180     frameData->client = new WebKit::FrameLoaderClient(frame);
181     frameData->frame = new Frame(webViewData->corePage, element, frameData->client);
182
183     FrameView* frameView = new FrameView(frameData->frame);
184     frameView->setContainingWindow(GTK_CONTAINER(webView));
185     frameData->frame->setView(frameView);
186     frameView->deref();
187     frameData->frame->init();
188     frameData->webView = webView;
189
190     return frame;
191 }
192
193 const gchar* webkit_web_frame_get_title(WebKitWebFrame* frame)
194 {
195     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
196
197     WebKitWebFramePrivate* frameData = WEBKIT_WEB_FRAME_GET_PRIVATE(frame);
198     return frameData->title;
199 }
200
201 const gchar* webkit_web_frame_get_uri(WebKitWebFrame* frame)
202 {
203     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
204
205     WebKitWebFramePrivate* frameData = WEBKIT_WEB_FRAME_GET_PRIVATE(frame);
206     return frameData->uri;
207 }
208
209 /**
210  * webkit_web_frame_get_web_view:
211  * @frame: a #WebKitWebFrame
212  *
213  * Returns the #WebKitWebView that manages this #WebKitWebFrame.
214  *
215  * The #WebKitWebView returned manages the entire hierarchy of #WebKitWebFrame
216  * objects that contains @frame.
217  *
218  * Return value: the #WebKitWebView that manages @frame
219  */
220 WebKitWebView* webkit_web_frame_get_web_view(WebKitWebFrame* frame)
221 {
222     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
223
224     WebKitWebFramePrivate* frameData = WEBKIT_WEB_FRAME_GET_PRIVATE(frame);
225     return frameData->webView;
226 }
227
228 /**
229  * webkit_web_frame_get_name:
230  * @frame: a #WebKitWebFrame
231  *
232  * Returns the @frame's name
233  *
234  * Return value: the name of @frame
235  */
236 const gchar* webkit_web_frame_get_name(WebKitWebFrame* frame)
237 {
238     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
239
240     WebKitWebFramePrivate* frameData = WEBKIT_WEB_FRAME_GET_PRIVATE(frame);
241
242     if (frameData->name)
243         return frameData->name;
244
245     Frame* coreFrame = core(frame);
246     g_return_val_if_fail(coreFrame, NULL);
247
248     String string = coreFrame->tree()->name();
249     frameData->name = g_strdup(string.utf8().data());
250
251     return frameData->name;
252 }
253
254 /**
255  * webkit_web_frame_get_parent:
256  * @frame: a #WebKitWebFrame
257  *
258  * Returns the @frame's parent frame, or %NULL if it has none.
259  *
260  * Return value: the parent #WebKitWebFrame or %NULL in case there is none
261  */
262 WebKitWebFrame* webkit_web_frame_get_parent(WebKitWebFrame* frame)
263 {
264     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
265
266     Frame* coreFrame = core(frame);
267     g_return_val_if_fail(coreFrame, NULL);
268
269     return kit(coreFrame->tree()->parent());
270 }
271
272 /**
273  * webkit_web_frame_load_request:
274  * @frame: a #WebKitWebFrame
275  * @request: a #WebKitNetworkRequest
276  *
277  * Connects to a given URI by initiating an asynchronous client request.
278  *
279  * Creates a provisional data source that will transition to a committed data
280  * source once any data has been received. Use webkit_web_frame_stop_loading() to
281  * stop the load. This function is typically invoked on the main frame.
282  */
283 void webkit_web_frame_load_request(WebKitWebFrame* frame, WebKitNetworkRequest* request)
284 {
285     g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
286     g_return_if_fail(WEBKIT_IS_NETWORK_REQUEST(request));
287
288     Frame* coreFrame = core(frame);
289     g_return_if_fail(coreFrame);
290
291     // TODO: Use the ResourceRequest carried by WebKitNetworkRequest when it gets implemented.
292     DeprecatedString string = DeprecatedString::fromUtf8(webkit_network_request_get_uri(request));
293     coreFrame->loader()->load(ResourceRequest(KURL(string)));
294 }
295
296 /**
297  * webkit_web_frame_stop_loading:
298  * @frame: a #WebKitWebFrame
299  *
300  * Stops any pending loads on @frame's data source, and those of its children.
301  */
302 void webkit_web_frame_stop_loading(WebKitWebFrame* frame)
303 {
304     g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
305
306     Frame* coreFrame = core(frame);
307     g_return_if_fail(coreFrame);
308
309     coreFrame->loader()->stopAllLoaders();
310 }
311
312 /**
313  * webkit_web_frame_reload:
314  * @frame: a #WebKitWebFrame
315  *
316  * Reloads the initial request.
317  */
318 void webkit_web_frame_reload(WebKitWebFrame* frame)
319 {
320     g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
321
322     Frame* coreFrame = core(frame);
323     g_return_if_fail(coreFrame);
324
325     coreFrame->loader()->reload();
326 }
327
328 /**
329  * webkit_web_frame_find_frame:
330  * @frame: a #WebKitWebFrame
331  * @name: the name of the frame to be found
332  *
333  * For pre-defined names, returns @frame if @name is "_self" or "_current",
334  * returns @frame's parent frame if @name is "_parent", and returns the main
335  * frame if @name is "_top". Also returns @frame if it is the main frame and
336  * @name is either "_parent" or "_top". For other names, this function returns
337  * the first frame that matches @name. This function searches @frame and its
338  * descendents first, then @frame's parent and its children moving up the
339  * hierarchy until a match is found. If no match is found in @frame's
340  * hierarchy, this function will search for a matching frame in other main
341  * frame hierarchies. Returns %NULL if no match is found.
342  *
343  * Return value: the found #WebKitWebFrame or %NULL in case none is found
344  */
345 WebKitWebFrame* webkit_web_frame_find_frame(WebKitWebFrame* frame, const gchar* name)
346 {
347     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
348     g_return_val_if_fail(name, NULL);
349
350     Frame* coreFrame = core(frame);
351     g_return_val_if_fail(coreFrame, NULL);
352
353     String nameString = String::fromUTF8(name);
354     return kit(coreFrame->tree()->find(AtomicString(nameString)));
355 }
356
357 /**
358  * webkit_web_frame_get_global_context:
359  * @frame: a #WebKitWebFrame
360  *
361  * Gets the global JavaScript execution context. Use this function to bridge
362  * between the WebKit and JavaScriptCore APIs.
363  *
364  * Return value: the global JavaScript context
365  */
366 JSGlobalContextRef webkit_web_frame_get_global_context(WebKitWebFrame* frame)
367 {
368     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
369
370     Frame* coreFrame = core(frame);
371     g_return_val_if_fail(coreFrame, NULL);
372
373     return toGlobalRef(coreFrame->scriptProxy()->globalObject()->globalExec());
374 }
375
376 /**
377  * webkit_web_frame_get_children:
378  * @frame: a #WebKitWebFrame
379  *
380  * Return value: child frames of @frame
381  */
382 GSList* webkit_web_frame_get_children(WebKitWebFrame* frame)
383 {
384     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
385
386     GSList* children = NULL;
387     Frame* coreFrame = core(frame);
388
389     for (Frame* child = coreFrame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
390         FrameLoader* loader = child->loader();
391         WebKit::FrameLoaderClient* client = static_cast<WebKit::FrameLoaderClient*>(loader->client());
392         if (client)
393           children = g_slist_append(children, client->webFrame());
394     }
395
396     return children;
397 }
398
399 /**
400  * webkit_web_frame_get_inner_text:
401  * @frame: a #WebKitWebFrame
402  *
403  * Return value: inner text of @frame
404  */
405 gchar* webkit_web_frame_get_inner_text(WebKitWebFrame* frame)
406 {
407     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
408
409     Frame* coreFrame = core(frame);
410     FrameView* view = coreFrame->view();
411
412     if (view->layoutPending())
413         view->layout();
414
415     Element* documentElement = coreFrame->document()->documentElement();
416     String string =  documentElement->innerText();
417     return g_strdup(string.utf8().data());
418 }
419
420 #if GTK_CHECK_VERSION(2,10,0)
421
422 // This could be shared between ports once it's complete
423 class PrintContext
424 {
425 public:
426     PrintContext(Frame* frame)
427         : m_frame(frame)
428     {
429     }
430
431     ~PrintContext()
432     {
433         m_pageRects.clear();
434     }
435
436     int pageCount()
437     {
438         return m_pageRects.size();
439     }
440
441     void computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight)
442     {
443         m_pageRects.clear();
444         outPageHeight = 0;
445
446         if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
447             return;
448
449         RenderView* root = static_cast<RenderView*>(m_frame->document()->renderer());
450
451         if (!root) {
452             LOG_ERROR("document to be printed has no renderer");
453             return;
454         }
455
456         if (userScaleFactor <= 0) {
457             LOG_ERROR("userScaleFactor has bad value %.2f", userScaleFactor);
458             return;
459         }
460
461         float ratio = printRect.height() / printRect.width();
462
463         float pageWidth  = (float)root->docWidth();
464         float pageHeight = pageWidth * ratio;
465         outPageHeight = pageHeight;   // this is the height of the page adjusted by margins
466         pageHeight -= headerHeight + footerHeight;
467
468         if (pageHeight <= 0) {
469             LOG_ERROR("pageHeight has bad value %.2f", pageHeight);
470             return;
471         }
472
473         float currPageHeight = pageHeight / userScaleFactor;
474         float docHeight = root->layer()->height();
475         float currPageWidth = pageWidth / userScaleFactor;
476
477         // always return at least one page, since empty files should print a blank page
478         float printedPagesHeight = 0.0;
479         do {
480             float proposedBottom = min(docHeight, printedPagesHeight + pageHeight);
481             m_frame->adjustPageHeight(&proposedBottom, printedPagesHeight, proposedBottom, printedPagesHeight);
482             currPageHeight = max(1.0f, proposedBottom - printedPagesHeight);
483
484             m_pageRects.append(IntRect(0, (int)printedPagesHeight, (int)currPageWidth, (int)currPageHeight));
485             printedPagesHeight += currPageHeight;
486         } while (printedPagesHeight < docHeight);
487     }
488
489     // TODO: eliminate width param
490     void begin(float width)
491     {
492         // By imaging to a width a little wider than the available pixels,
493         // thin pages will be scaled down a little, matching the way they
494         // print in IE and Camino. This lets them use fewer sheets than they
495         // would otherwise, which is presumably why other browsers do this.
496         // Wide pages will be scaled down more than this.
497         const float PrintingMinimumShrinkFactor = 1.25f;
498
499         // This number determines how small we are willing to reduce the page content
500         // in order to accommodate the widest line. If the page would have to be
501         // reduced smaller to make the widest line fit, we just clip instead (this
502         // behavior matches MacIE and Mozilla, at least)
503         const float PrintingMaximumShrinkFactor = 2.0f;
504
505         float minLayoutWidth = width * PrintingMinimumShrinkFactor;
506         float maxLayoutWidth = width * PrintingMaximumShrinkFactor;
507
508         // FIXME: This will modify the rendering of the on-screen frame.
509         // Could lead to flicker during printing.
510         m_frame->setPrinting(true, minLayoutWidth, maxLayoutWidth, true);
511     }
512
513     // TODO: eliminate width param
514     void spoolPage(GraphicsContext& ctx, int pageNumber, float width)
515     {
516         IntRect pageRect = m_pageRects[pageNumber];
517         float scale = width / pageRect.width();
518
519         ctx.save();
520         ctx.scale(FloatSize(scale, scale));
521         ctx.translate(-pageRect.x(), -pageRect.y());
522         ctx.clip(pageRect);
523         m_frame->paint(&ctx, pageRect);
524         ctx.restore();
525     }
526
527     void end()
528     {
529         m_frame->setPrinting(false, 0, 0, true);
530     }
531
532 protected:
533     Frame* m_frame;
534     Vector<IntRect> m_pageRects;
535 };
536
537 static void begin_print(GtkPrintOperation* op, GtkPrintContext* context, gpointer user_data)
538 {
539     PrintContext* printContext = reinterpret_cast<PrintContext*>(user_data);
540
541     float width = gtk_print_context_get_width(context);
542     float height = gtk_print_context_get_height(context);
543     FloatRect printRect = FloatRect(0, 0, width, height);
544
545     printContext->begin(width);
546
547     // TODO: Margin adjustments and header/footer support
548     float headerHeight = 0;
549     float footerHeight = 0;
550     float pageHeight; // height of the page adjusted by margins
551     printContext->computePageRects(printRect, headerHeight, footerHeight, 1.0, pageHeight);
552     gtk_print_operation_set_n_pages(op, printContext->pageCount());
553 }
554
555 static void draw_page(GtkPrintOperation* op, GtkPrintContext* context, gint page_nr, gpointer user_data)
556 {
557     PrintContext* printContext = reinterpret_cast<PrintContext*>(user_data);
558
559     cairo_t* cr = gtk_print_context_get_cairo_context(context);
560     GraphicsContext ctx(cr);
561     float width = gtk_print_context_get_width(context);
562     printContext->spoolPage(ctx, page_nr, width);
563 }
564
565 static void end_print(GtkPrintOperation* op, GtkPrintContext* context, gpointer user_data)
566 {
567     PrintContext* printContext = reinterpret_cast<PrintContext*>(user_data);
568     printContext->end();
569 }
570
571 void webkit_web_frame_print(WebKitWebFrame* frame)
572 {
573     GtkWidget* topLevel = gtk_widget_get_toplevel(GTK_WIDGET(webkit_web_frame_get_web_view(frame)));
574     if (!GTK_WIDGET_TOPLEVEL(topLevel))
575         topLevel = NULL;
576
577     Frame* coreFrame = core(frame);
578     PrintContext printContext(coreFrame);
579
580     GtkPrintOperation* op = gtk_print_operation_new();
581     g_signal_connect(G_OBJECT(op), "begin-print", G_CALLBACK(begin_print), &printContext);
582     g_signal_connect(G_OBJECT(op), "draw-page", G_CALLBACK(draw_page), &printContext);
583     g_signal_connect(G_OBJECT(op), "end-print", G_CALLBACK(end_print), &printContext);
584     GError *error = NULL;
585     gtk_print_operation_run(op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW(topLevel), &error);
586     g_object_unref(op);
587
588     if (error) {
589         GtkWidget* dialog = gtk_message_dialog_new(GTK_WINDOW(topLevel),
590                                                    GTK_DIALOG_DESTROY_WITH_PARENT,
591                                                    GTK_MESSAGE_ERROR,
592                                                    GTK_BUTTONS_CLOSE,
593                                                    "%s", error->message);
594         g_error_free(error);
595
596         g_signal_connect(dialog, "response", G_CALLBACK(gtk_widget_destroy), NULL);
597         gtk_widget_show(dialog);
598     }
599 }
600
601 #else
602
603 void webkit_web_frame_print(WebKitWebFrame*)
604 {
605     g_warning("Printing support is not available in older versions of GTK+");
606 }
607
608 #endif
609
610 }