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);
}
