static void testWebViewGroupDefault(Test* test, gconstpointer) { // Default group is shared by all WebViews by default. GRefPtr<WebKitWebView> webView1 = WEBKIT_WEB_VIEW(webkit_web_view_new()); GRefPtr<WebKitWebView> webView2 = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_assert(webkit_web_view_get_group(webView1.get()) == webkit_web_view_get_group(webView2.get())); // Settings are shared by all web view in the same group. g_assert(webkit_web_view_get_settings(webView1.get()) == webkit_web_view_get_settings(webView2.get())); g_assert(webkit_web_view_get_settings(webView1.get()) == webkit_web_view_group_get_settings(webkit_web_view_get_group(webView2.get()))); }
static void auth_browser_init (AuthBrowser *self) { AuthBrowserPrivate *priv = GET_PRIVATE (self); GtkWidget *vbox, *scrolled_window; priv->title = NULL; priv->progress = 0; priv->stop_url = NULL; priv->callback = NULL; vbox = gtk_vbox_new (FALSE, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); priv->webview = WEBKIT_WEB_VIEW (webkit_web_view_new ()); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (priv->webview)); gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0); priv->window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (priv->window), DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT); gtk_widget_set_name (priv->window, "AuthBrowser"); // gtk_window_set_screen (GTK_WINDOW (priv->window), gdk_screen_get_default ()); gtk_container_add (GTK_CONTAINER (priv->window), vbox); g_signal_connect (G_OBJECT (priv->webview), "title-changed", G_CALLBACK (title_change_cb), self); g_signal_connect (G_OBJECT (priv->webview), "load-progress-changed", G_CALLBACK (progress_change_cb), self); g_signal_connect (G_OBJECT (priv->webview), "load-committed", G_CALLBACK (load_commit_cb), self); }
static void testWebViewSettings(WebViewTest* test, gconstpointer) { WebKitSettings* defaultSettings = webkit_web_view_get_settings(test->m_webView); test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(defaultSettings)); g_assert(defaultSettings); g_assert(webkit_settings_get_enable_javascript(defaultSettings)); GRefPtr<WebKitSettings> newSettings = adoptGRef(webkit_settings_new()); test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(newSettings.get())); g_object_set(G_OBJECT(newSettings.get()), "enable-javascript", FALSE, NULL); webkit_web_view_set_settings(test->m_webView, newSettings.get()); WebKitSettings* settings = webkit_web_view_get_settings(test->m_webView); g_assert(settings != defaultSettings); g_assert(!webkit_settings_get_enable_javascript(settings)); GRefPtr<GtkWidget> webView2 = webkit_web_view_new(); test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webView2.get())); webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView2.get()), settings); g_assert(webkit_web_view_get_settings(WEBKIT_WEB_VIEW(webView2.get())) == settings); GRefPtr<WebKitSettings> newSettings2 = adoptGRef(webkit_settings_new()); test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(newSettings2.get())); webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView2.get()), newSettings2.get()); settings = webkit_web_view_get_settings(WEBKIT_WEB_VIEW(webView2.get())); g_assert(settings == newSettings2.get()); g_assert(webkit_settings_get_enable_javascript(settings)); GRefPtr<GtkWidget> webView3 = webkit_web_view_new_with_settings(newSettings2.get()); test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(webView3.get())); g_assert(webkit_web_view_get_settings(WEBKIT_WEB_VIEW(webView3.get())) == newSettings2.get()); }
static void create () { main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (main_window), 1024, 780); gtk_window_set_title (GTK_WINDOW (main_window), "Khan Academy"); g_signal_connect(main_window, "destroy", G_CALLBACK (gtk_main_quit), NULL); web_view = webkit_web_view_new (); gtk_container_add (GTK_CONTAINER (main_window), web_view); WebKitSettings *settings = webkit_web_view_get_settings (WEBKIT_WEB_VIEW (web_view)); g_object_set (G_OBJECT (settings), "enable-fullscreen", TRUE, "enable-developer-extras", TRUE, "enable-plugins", FALSE, NULL); g_object_connect (G_OBJECT(web_view), "signal::web-process-crashed", G_CALLBACK (crashed), NULL, "signal::load-changed", G_CALLBACK (changed), NULL, "signal::load-failed", G_CALLBACK (failed), NULL, NULL); gtk_widget_show_all (main_window); }
WebKitWebView *control___::new_wwv__(Gtk::ScrolledWindow* sw){ WebKitWebView *wwv = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_object_ref_sink(G_OBJECT(wwv)); switch(use_){ case use_for_browse_: names_[wwv]=this; if(!sw){ sw=Gtk::manage(new Gtk::ScrolledWindow()); } page_[sw]=new page___(page_.size(),n_,wwv,sw); break; } if(!user_agent_.empty()){ WebKitWebSettings* wws=webkit_web_view_get_settings(wwv); WebKitWebSettings* wws2; //wws2=wws; wws2=webkit_web_settings_copy(wws); //wws2=(WebKitWebSettings*)webkit_web_settings_new(); g_object_set((GObject*)wws2, "user-agent", user_agent_.c_str(), NULL); webkit_web_view_set_settings(wwv,wws2); } zhenting__(wwv); return wwv; }
int main(int argc, char** argv) { gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(window), HEIGHT, WIDTH); // hardwired position GTK_WIN_POS_CENTER_ALWAYS gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS); g_signal_connect(window, "key-press-event", G_CALLBACK(on_key_press), NULL); g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL); web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); signal(SIGHUP, reload_browser); gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(web_view)); webkit_web_view_load_uri(web_view, DEFAULT_URL); // maximize() gtk_window_maximize(GTK_WINDOW(window)); gtk_window_fullscreen(GTK_WINDOW(window)); gtk_window_set_decorated(GTK_WINDOW(window), FALSE); gtk_widget_show_all(window); gtk_main(); return 0; }
static GtkWidget* createWindow(WebKitWebView** outWebView) { WebKitWebView *webView; GtkWidget *vbox; GtkWidget *window; GtkWidget *uriEntry; GtkWidget *statusbar; g_atomic_int_inc(&windowCount); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(window), 800, 600); gtk_widget_set_name(window, "GtkLauncher"); webView = WEBKIT_WEB_VIEW(webkit_web_view_new()); uriEntry = gtk_entry_new(); vbox = gtk_vbox_new(FALSE, 0); statusbar = createStatusbar(webView); gtk_box_pack_start(GTK_BOX(vbox), createToolbar(uriEntry, webView), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), createBrowser(window, uriEntry, statusbar, webView), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); g_signal_connect(window, "destroy", G_CALLBACK(destroyCb), NULL); if (outWebView) *outWebView = webView; return window; }
int main (int argc, gchar* argv[]) { gtk_init(&argc, &argv); if (argc < 2) { printf("Usage: URI [filename]\n"); return 1; } const gchar *uri = argv[1]; const gchar *filename = argc > 2 ? argv[2] : "a.pdf"; if (!g_thread_supported()) {g_thread_init(NULL);} WebKitWebView *web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_signal_connect(web_view, "notify::load-status", G_CALLBACK(load_status_cb), (gpointer) filename); GtkWidget *offscren = gtk_offscreen_window_new(); gtk_container_add(GTK_CONTAINER(offscren), GTK_WIDGET(web_view)); gtk_widget_show_all(offscren); webkit_web_view_load_uri(web_view, uri); gtk_main(); return 0; }
WindowShowRelatedVerses::WindowShowRelatedVerses(GtkWidget * parent_layout, GtkAccelGroup *accelerator_group, bool startup): FloatingWindow(parent_layout, widShowRelatedVerses, _("Related verses"), startup), myreference(0) // Window showing related verses. { item_type = ritNone; thread_runs = false; event_id = 0; scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_container_add(GTK_CONTAINER(vbox_client), scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_SHADOW_IN); webview = webkit_web_view_new(); gtk_widget_show(webview); gtk_container_add(GTK_CONTAINER(scrolledwindow), webview); connect_focus_signals (webview); g_signal_connect((gpointer) webview, "navigation-policy-decision-requested", G_CALLBACK(on_navigation_policy_decision_requested), gpointer(this)); last_focused_widget = webview; gtk_widget_grab_focus (last_focused_widget); button_item = gtk_button_new (); }
int main(int argc, char** argv) { // Make sure that both GAIL and the ATK bridge are loaded. g_setenv("GTK_MODULES", "gail:atk-bridge", TRUE); gtk_init(&argc, &argv); WebKitWebView* webView = WEBKIT_WEB_VIEW(webkit_web_view_new()); webkit_web_view_load_html(webView, "<html>" " <body>" " <h1>This is a test</h1>" " <p>This is a paragraph with some plain text.</p>" " <p>This paragraph contains <a href=\"http://www.webkitgtk.org\">a link</a> in the middle.</p>" " </body>" "</html>", 0); GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(webView)); gtk_widget_show_all(window); g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), 0); g_signal_connect(webView, "load-changed", G_CALLBACK(loadChangedCallback), 0); gtk_main(); }
static void phidias_items_classic_init (PhidiasItemsClassic *item) { GtkWidget *scroll; GtkCellRenderer *renderer; GtkTreeViewColumn *col; GtkTreeSelection *selection; item->priv = PHIDIAS_ITEMS_CLASSIC_GET_PRIVATE (item); item->priv->list = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (item->priv->list), FALSE); renderer = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Title", renderer, "text", ITEM_INFO_TITLE, NULL); gtk_tree_view_column_set_cell_data_func (col, renderer, set_line_style, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (item->priv->list), col); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (item->priv->list)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (item_selected_cb), item); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll), item->priv->list); gtk_paned_add1 (GTK_PANED (item), scroll); item->priv->description = webkit_web_view_new (); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll), item->priv->description); gtk_paned_add2 (GTK_PANED (item), scroll); }
static void html_init(Html *html) { html->webview = WEBKIT_WEB_VIEW(webkit_web_view_new()); html->scrolled = gtk_scrolled_window_new(0,0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (html->scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); GTK_WIDGET_SET_FLAGS (html->scrolled, GTK_CAN_FOCUS); gtk_container_add(GTK_CONTAINER (html->scrolled), GTK_WIDGET(html->webview)); g_signal_connect(G_OBJECT (html->webview), "title-changed", G_CALLBACK (webkit_web_view_title_changed_cb), html); g_signal_connect(G_OBJECT (html->webview), "button-press-event", G_CALLBACK (webkit_web_view_mouse_click_cb), html); g_signal_connect(G_OBJECT (html->webview), "hovering-over-link", G_CALLBACK (webkit_web_view_hovering_over_link_cb), html); g_signal_connect(G_OBJECT (html->webview), "load-committed", G_CALLBACK (webkit_web_view_load_committed_cb), html); gtk_drag_dest_unset(GTK_WIDGET(html->webview)); }
Win* win_create(void) { Win *w; GdkGeometry g; GtkPolicyType h, v; w = emalloc(sizeof(Win)); w->win = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL)); w->scroll = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL)); w->web = WEBKIT_WEB_VIEW(webkit_web_view_new()); w->ignore = w->zoom = FALSE; g.min_width = g.min_height = 1; data.wins = g_list_append(data.wins, w); webkit_web_view_set_full_content_zoom(w->web, TRUE); webkit_web_view_set_zoom_level(w->web, ZOOM); gtk_window_set_geometry_hints(w->win, NULL, &g, GDK_HINT_MIN_SIZE); gtk_window_set_default_size(w->win, WIDTH, HEIGHT); gtk_container_add(GTK_CONTAINER(w->scroll), GTK_WIDGET(w->web)); gtk_container_add(GTK_CONTAINER(w->win), GTK_WIDGET(w->scroll)); gtk_widget_show_all(GTK_WIDGET(w->win)); gdk_window_set_events(GWIN(w), GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter(GWIN(w), atom_propertynotify, w); event_init(w); h = SHOW_HSCROLL ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER; v = SHOW_VSCROLL ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER; gtk_scrolled_window_set_policy(w->scroll, h, v); gtk_widget_grab_focus(GTK_WIDGET(w->web)); return w; }
GtkWidget* webkit_view___::webview_new__(GtkWidget* scrolled) { GtkWidget* webview = webkit_web_view_new (); //g_object_ref_sink(webview); gtk_object_set_data(GTK_OBJECT(webview),object_data_view_,(gpointer)this); if(scrolled) { gtk_object_set_data(GTK_OBJECT(webview),object_data_scrolled_,(gpointer)scrolled); //gtk_container_add (GTK_CONTAINER (scrolled), webview); GtkWidget* scrolled2 = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled2), webview); gtk_container_add (GTK_CONTAINER (scrolled), scrolled2); outer_scrolled_ = scrolled2; if(is_app_paintable_) { webkit_web_view_set_transparent(WEBKIT_WEB_VIEW(webview), true); } g_signal_connect(webview,"window-object-cleared",G_CALLBACK(window_object_cleared__),NULL); g_object_connect(G_OBJECT(webview), "signal::geolocation-policy-decision-requested", geolocation_policy_decision_requested__, 0, NULL); signal_connect__(webview); } if(!user_agent_.empty()) { WebKitWebSettings* wws=webkit_web_view_get_settings(WEBKIT_WEB_VIEW(webview)); WebKitWebSettings* wws2=webkit_web_settings_copy(wws); g_object_set((GObject*)wws2, "user-agent", user_agent_.c_str(), NULL); webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webview), wws2); } return webview; }
static void createBrowserWindow(const gchar *uri, WebKitSettings *webkitSettings, gboolean shouldLoadSession) { GtkWidget *webView = webkit_web_view_new(); if (editorMode) webkit_web_view_set_editable(WEBKIT_WEB_VIEW(webView), TRUE); GtkWidget *mainWindow = browser_window_new(WEBKIT_WEB_VIEW(webView), NULL); if (backgroundColor) browser_window_set_background_color(BROWSER_WINDOW(mainWindow), backgroundColor); if (webkitSettings) webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView), webkitSettings); if (!editorMode) { if (shouldLoadSession && sessionFile) browser_window_load_session(BROWSER_WINDOW(mainWindow), sessionFile); else { gchar *url = argumentToURL(uri); browser_window_load_uri(BROWSER_WINDOW(mainWindow), url); g_free(url); } } gtk_widget_grab_focus(webView); gtk_widget_show(mainWindow); }
static GtkWidget *create_htmlview(GtkNotebook *notebook) { #if defined(USE_WEBKITGTK) WebKitWebView *html_widget = WEBKIT_WEB_VIEW(webkit_web_view_new()); #elif defined(USE_GTKHTML) GtkWidget *html_widget = gtk_html_new(); #endif GtkWidget *scrolled; SYLPF_START_FUNC; scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(html_widget)); gtk_widget_show_all(GTK_WIDGET(scrolled)); gtk_container_add(GTK_CONTAINER(notebook), GTK_WIDGET(scrolled)); gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook), GTK_WIDGET(scrolled), _("HTML")); SYLPF_RETURN_VALUE(GTK_WIDGET(html_widget)); }
WebKitWebView* create_inspector_cb (WebKitWebInspector* web_inspector, WebKitWebView* page, gpointer data){ (void) data; (void) page; (void) web_inspector; GtkWidget* scrolled_window; GtkWidget* new_web_view; GUI *g = &uzbl.gui; g->inspector_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_signal_connect(G_OBJECT(g->inspector_window), "delete-event", G_CALLBACK(hide_window_cb), NULL); gtk_window_set_title(GTK_WINDOW(g->inspector_window), "Uzbl WebInspector"); gtk_window_set_default_size(GTK_WINDOW(g->inspector_window), 400, 300); gtk_widget_show(g->inspector_window); scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(g->inspector_window), scrolled_window); gtk_widget_show(scrolled_window); new_web_view = webkit_web_view_new(); gtk_container_add(GTK_CONTAINER(scrolled_window), new_web_view); return WEBKIT_WEB_VIEW(new_web_view); }
/*@null@*/ WebKitWebView* create_web_view_cb (WebKitWebView *web_view, WebKitWebFrame *frame, gpointer user_data) { (void) web_view; (void) frame; (void) user_data; // unfortunately we don't know the URL at this point; all webkit-gtk will // tell us is that we're opening a new window. // // (we can't use the new-window-policy-decision-requested event; it doesn't // fire when Javascript requests a new window with window.open().) // // so, we have to create a temporary web view and allow it to load. webkit // segfaults if we try to destroy it or mark it for garbage collection in // create_web_view_got_uri_cb, so we might as well keep it around and reuse // it. if(!uzbl.state._tmp_web_view) { uzbl.state._tmp_web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_object_connect (uzbl.state._tmp_web_view, "signal::notify::uri", G_CALLBACK(create_web_view_got_uri_cb), NULL, NULL); // we're taking ownership of this WebView (sinking its floating reference // since it will never be added to a display widget). g_object_ref_sink(uzbl.state._tmp_web_view); } return uzbl.state._tmp_web_view; }
/********** * Name: create_labeled_tab * Input: 'cb_data' - the browser_window passed in * Output: none * Function: Build a new scrolling window, set the size, create the button * and tab area on the window, and display it all. Used by * create_browser function. */ void create_labeled_tab(void* cb_data) { GtkWidget* scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (scrolled_window, WINDOW_WIDTH, WINDOW_HEIGHT); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show(scrolled_window); // Create 'button-press-event' callback event data browser_window* b_window = (browser_window*)cb_data; // Create web-page rendering area b_window->web_view = WEBKIT_WEB_VIEW (webkit_web_view_new ()); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET(b_window->web_view)); webkit_web_view_open(b_window->web_view, "about:blank"); GtkWidget* label = gtk_label_new(b_window->tab_label); gtk_widget_show(label); // Attach tab to the browser gtk_notebook_append_page (GTK_NOTEBOOK (b_window->notebook), scrolled_window, label); }
static void document_webkit_init (Document_Webkit * object) { Document_WebkitDetails *docdet; docdet = DOCUMENT_WEBKIT_GET_PRIVATE(object); docdet->help_view= WEBKIT_WEB_VIEW(webkit_web_view_new ()); docdet->help_scrolled_window = gtk_scrolled_window_new(NULL, NULL); docdet->label = gtk_label_new (""); gtk_widget_show (docdet->label); gtk_container_add(GTK_CONTAINER(docdet->help_scrolled_window), GTK_WIDGET(docdet->help_view)); docdet->container = gtk_vbox_new (FALSE, 0); /* create incremental search widget */ docdet->searchbar = search_infobar_new(); gtk_box_pack_start(GTK_BOX(docdet->container), docdet->searchbar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(docdet->container), docdet->help_scrolled_window, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(docdet->help_view), "navigation-policy-decision-requested", G_CALLBACK(webkit_link_clicked), NULL); g_signal_connect (G_OBJECT(docdet->help_view), "notify::title", G_CALLBACK (notify_title_cb), object); gtk_widget_show_all(docdet->help_scrolled_window); }
int main (int argc, char* argv[]) { const char *uri; WebKitWebView* web_view; GMainLoop* loop; SoupSession *session; gtk_init(&argc, &argv); if (argc == 1) { printf("Usage: URI\n"); return 1; } uri = argv[1]; if (!g_thread_supported()) {g_thread_init(NULL);} loop = g_main_loop_new(NULL, TRUE); session = webkit_get_default_session(); g_signal_connect(session, "request-started", G_CALLBACK(request_started_cb), NULL); web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_object_ref_sink(G_OBJECT(web_view)); g_signal_connect(web_view, "notify::load-status", G_CALLBACK(load_status_cb), loop); webkit_web_view_load_uri(web_view, uri); g_main_loop_run(loop); g_object_unref(web_view); return 0; }
static void test_webkit_web_view_icon_uri() { gboolean been_to_icon_loaded = FALSE; WebKitWebView* view = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_object_ref_sink(G_OBJECT(view)); loop = g_main_loop_new(NULL, TRUE); g_object_connect(G_OBJECT(view), "signal::notify::icon-uri", icon_uri_changed_cb, NULL, "signal::icon-loaded", icon_loaded_cb, &been_to_icon_loaded, NULL); webkit_web_view_load_uri(view, base_uri); guint timeout_id = g_timeout_add(500, timeout_cb, 0); g_main_loop_run(loop); g_source_remove(timeout_id); g_assert(been_to_icon_loaded); g_object_unref(view); }
Tab *factory_build_tab(Tab *tab) { char tabnr[3] = ""; GtkWidget *vbox; GtkWidget *ebox; GtkWidget *number; GtkWidget *label; GtkWidget *view; vbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); ebox = gtk_event_box_new(); gtk_widget_set_name(ebox, "tab"); sprintf(tabnr, "%d", g_list_length(awb.tabs)); number = gtk_label_new(tabnr); gtk_widget_set_name(number, "tabnr"); label = gtk_label_new("about:blank"); view = webkit_web_view_new(); tab->ebox = ebox; tab->number = number; tab->label = label; tab->view = view; gtk_box_pack_start(GTK_BOX(awb.gui.tabbar), ebox, true, true, 0); gtk_container_add(GTK_CONTAINER(ebox), vbox); gtk_box_pack_start(GTK_BOX(vbox), number, false, false, 0); gtk_box_pack_start(GTK_BOX(vbox), label, true, true, 0); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); gtk_misc_set_padding(GTK_MISC(number), 3, 0); g_object_ref(view); return tab; }
static void test_webkit_web_view_fullscreen(gconstpointer blocked) { GtkWidget* window; GtkWidget* web_view; WebKitWebSettings *settings; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); web_view = webkit_web_view_new(); settings = webkit_web_view_get_settings(WEBKIT_WEB_VIEW(web_view)); g_object_set(settings, "enable-fullscreen", TRUE, NULL); webkit_web_view_set_settings(WEBKIT_WEB_VIEW(web_view), settings); gtk_container_add(GTK_CONTAINER(window), web_view); gtk_widget_show_all(window); loop = g_main_loop_new(NULL, TRUE); g_signal_connect(web_view, "entering-fullscreen", G_CALLBACK(entering_fullscreen_cb), (gpointer) blocked); g_signal_connect(web_view, "leaving-fullscreen", G_CALLBACK(leaving_fullscreen_cb), NULL); webkit_web_view_load_string(WEBKIT_WEB_VIEW(web_view), "<html><body>" "<script>" "var eventName = 'keypress';" "document.addEventListener(eventName, function () {" " document.documentElement.webkitRequestFullScreen();" "}, false);" "</script></body></html>", NULL, NULL, NULL); g_timeout_add(100, (GSourceFunc) emitKeyStroke, WEBKIT_WEB_VIEW(web_view)); g_main_loop_run(loop); gtk_widget_destroy(window); }
int main(int argc, char** argv) { gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_signal_connect(window, "key-press-event", G_CALLBACK(on_key_press), NULL); g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL); web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); signal(SIGHUP, reload_browser); gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(web_view)); if(argc > 1) { webkit_web_view_load_uri(web_view, argv[1]); } else { webkit_web_view_load_uri(web_view, default_url); } maximize(); gtk_widget_show_all(window); gtk_main(); return 0; }
static void test_webkit_atk_get_text_at_offset_text_input(void) { WebKitWebView* webView; AtkObject* obj; GMainLoop* loop; AtkText* text_obj; webView = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_object_ref_sink(webView); GtkAllocation alloc = { 0, 0, 800, 600 }; gtk_widget_size_allocate(GTK_WIDGET(webView), &alloc); webkit_web_view_load_string(webView, contentsInTextInput, NULL, NULL, NULL); loop = g_main_loop_new(NULL, TRUE); g_timeout_add(100, (GSourceFunc)bail_out, loop); g_main_loop_run(loop); /* Get to the inner AtkText object */ obj = gtk_widget_get_accessible(GTK_WIDGET(webView)); g_assert(obj); obj = atk_object_ref_accessible_child(obj, 0); g_assert(obj); obj = atk_object_ref_accessible_child(obj, 0); g_assert(obj); text_obj = ATK_TEXT(obj); g_assert(ATK_IS_TEXT(text_obj)); run_get_text_tests(text_obj); g_object_unref(webView); }
static void hit_test_result_fixture_setup(HitTestResultFixture* fixture, gconstpointer data) { fixture->webView = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_object_ref_sink(fixture->webView); loop = g_main_loop_new(NULL, TRUE); fixture->info = (TestInfo*)data; }
static void testWebkitAtkGetTextInTable(void) { WebKitWebView* webView; AtkObject* obj; GMainLoop* loop; webView = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_object_ref_sink(webView); GtkAllocation alloc = { 0, 0, 800, 600 }; gtk_widget_size_allocate(GTK_WIDGET(webView), &alloc); webkit_web_view_load_string(webView, contentsInTable, NULL, NULL, NULL); loop = g_main_loop_new(NULL, TRUE); g_timeout_add(100, (GSourceFunc)bail_out, loop); g_main_loop_run(loop); obj = gtk_widget_get_accessible(GTK_WIDGET(webView)); g_assert(obj); obj = atk_object_ref_accessible_child(obj, 0); g_assert(obj); /* Tables should not implement AtkText */ g_assert(G_TYPE_INSTANCE_GET_INTERFACE(obj, ATK_TYPE_TEXT, AtkTextIface) == NULL); g_object_unref(obj); g_object_unref(webView); }
int main (int argc, char* argv[]) { const char *uri; WebKitWebView *web_view; Ctx ctx; gtk_init(&argc, &argv); if (argc == 1) { printf("Usage: URI\n"); return 1; } uri = argv[1]; if (!g_thread_supported()) { g_thread_init(NULL); } web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_object_ref_sink(G_OBJECT(web_view)); g_signal_connect(web_view, "notify::load-status", G_CALLBACK(load_status_cb), &ctx); g_signal_connect(web_view, "console-message", G_CALLBACK(console_message_cb), NULL); webkit_web_view_load_uri(web_view, uri); ctx.loop = g_main_loop_new(NULL, TRUE); ctx.start_time = g_get_monotonic_time(); g_main_loop_run(ctx.loop); g_object_unref(web_view); return 0; }
static void test_webkit_web_data_source_unreachable_uri() { /* FIXME: this test fails currently. */ return; WebKitWebView* view; GMainLoop* loop; view = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_object_ref_sink(view); loop = g_main_loop_new(NULL, TRUE); g_signal_connect(view, "notify::load-status", G_CALLBACK(notify_load_status_unreachable_cb), loop); webkit_web_view_load_uri(view, "http://this.host.does.not.exist/doireallyexist.html"); waitTimer = g_timeout_add_seconds(defaultTimeout, (GSourceFunc)wait_timer_fired, loop); g_main_loop_run(loop); if (waitTimer) g_source_remove(waitTimer); waitTimer = 0; g_main_loop_unref(loop); g_object_unref(view); }