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 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 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);
}
static void testWebKitSettingsUserAgent(WebViewTest* test, gconstpointer)
{
GRefPtr<WebKitSettings> settings = adoptGRef(webkit_settings_new());
CString defaultUserAgent = webkit_settings_get_user_agent(settings.get());
webkit_web_view_set_settings(test->m_webView, settings.get());
g_assert(g_strstr_len(defaultUserAgent.data(), -1, "Safari"));
g_assert(g_strstr_len(defaultUserAgent.data(), -1, "Chromium"));
g_assert(g_strstr_len(defaultUserAgent.data(), -1, "Chrome"));
webkit_settings_set_user_agent(settings.get(), 0);
g_assert_cmpstr(defaultUserAgent.data(), ==, webkit_settings_get_user_agent(settings.get()));
assertThatUserAgentIsSentInHeaders(test, defaultUserAgent.data());
webkit_settings_set_user_agent(settings.get(), "");
g_assert_cmpstr(defaultUserAgent.data(), ==, webkit_settings_get_user_agent(settings.get()));
const char* funkyUserAgent = "Funky!";
webkit_settings_set_user_agent(settings.get(), funkyUserAgent);
g_assert_cmpstr(funkyUserAgent, ==, webkit_settings_get_user_agent(settings.get()));
assertThatUserAgentIsSentInHeaders(test, funkyUserAgent);
webkit_settings_set_user_agent_with_application_details(settings.get(), "WebKitGTK+", 0);
const char* userAgentWithNullVersion = webkit_settings_get_user_agent(settings.get());
g_assert_cmpstr(g_strstr_len(userAgentWithNullVersion, -1, defaultUserAgent.data()), ==, userAgentWithNullVersion);
g_assert(g_strstr_len(userAgentWithNullVersion, -1, "WebKitGTK+"));
webkit_settings_set_user_agent_with_application_details(settings.get(), "WebKitGTK+", "");
g_assert_cmpstr(webkit_settings_get_user_agent(settings.get()), ==, userAgentWithNullVersion);
webkit_settings_set_user_agent_with_application_details(settings.get(), "WebCatGTK+", "3.4.5");
const char* newUserAgent = webkit_settings_get_user_agent(settings.get());
g_assert(g_strstr_len(newUserAgent, -1, "3.4.5"));
g_assert(g_strstr_len(newUserAgent, -1, "WebCatGTK+"));
}
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;
}
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
mu_msg_body_view_init (MuMsgBodyView *obj)
{
obj->_priv = MU_MSG_BODY_VIEW_GET_PRIVATE(obj);
obj->_priv->_msg = NULL;
obj->_priv->_view_mode = VIEW_MODE_NONE;
obj->_priv->_settings = webkit_web_settings_new ();
g_object_set (G_OBJECT(obj->_priv->_settings),
"enable-scripts", FALSE,
"auto-load-images", TRUE,
"enable-plugins", FALSE,
NULL);
webkit_web_view_set_settings (WEBKIT_WEB_VIEW(obj),
obj->_priv->_settings);
webkit_web_view_set_editable (WEBKIT_WEB_VIEW(obj), FALSE);
/* to support cid: */
g_signal_connect (obj, "resource-request-starting",
G_CALLBACK (on_resource_request_starting), NULL);
/* handle navigation requests */
g_signal_connect (obj, "navigation-policy-decision-requested",
G_CALLBACK (on_navigation_policy_decision_requested), NULL);
/* handle right-button clicks */
g_signal_connect (obj, "button-press-event",
G_CALLBACK(on_button_press_event), NULL);
}
static WebKitWebView*
createWebViewCb(WebKitWebView* webView, WebKitWebFrame* web_frame, GtkWidget* window)
{
WebKitWebView *newWebView;
createWindow(&newWebView);
webkit_web_view_set_settings(newWebView, webkit_web_view_get_settings(webView));
return newWebView;
}
int main(int argc, gchar* argv[]) {
gtk_init(&argc, &argv);
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new("URL");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_add_group(context, gtk_get_option_group(TRUE));
if (!g_option_context_parse(context, &argc, &argv, &error)) {
errx(1, "option parsing failed: %s", error->message);
}
if (argc < 2) {
printf("Usage: %s [OPTION...] URL\n", argv[0]);
printf("Try '%s --help' for more information.\n", argv[0]);
return 1;
}
todo = (mhtml_file != NULL) + (html_file != NULL) + (png_file != NULL) + (title_file != NULL);
if (!todo) {
printf("Specify at least one of: --mhtml, --html, --png, --title\n");
printf("Try '%s --help' for more information.\n", argv[0]);
return 1;
}
const gchar *url = argv[1];
if (g_uri_parse_scheme(url) == NULL) {
errx(1, "invalid URI: %s", url);
}
WebKitWebView *web_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
g_signal_connect(web_view, "load-changed", G_CALLBACK(load_changed), NULL);
g_signal_connect(web_view, "load-failed", G_CALLBACK(load_failed), NULL);
WebKitSettings *settings = webkit_settings_new_with_settings(
"user-agent", USER_AGENT,
"enable-javascript", enable_js,
"enable-java", FALSE,
"enable-plugins", FALSE,
"enable-private-browsing", TRUE,
"enable-offline-web-application-cache", FALSE,
"enable-page-cache", FALSE,
NULL
);
webkit_web_view_set_settings(web_view, settings);
GtkWidget *window = gtk_offscreen_window_new();
gtk_window_set_default_size(GTK_WINDOW(window), 1280, 1024);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(web_view));
gtk_widget_show_all(window);
webkit_web_view_load_uri(web_view, url);
gtk_main();
return 0;
}
static GtkWidget *webViewCreate(WebKitWebView *webView, WebKitNavigationAction *navigation, BrowserWindow *window)
{
WebKitWebView *newWebView = WEBKIT_WEB_VIEW(webkit_web_view_new_with_related_view(webView));
webkit_web_view_set_settings(newWebView, webkit_web_view_get_settings(webView));
GtkWidget *newWindow = browser_window_new(newWebView, GTK_WINDOW(window));
g_signal_connect(newWebView, "ready-to-show", G_CALLBACK(webViewReadyToShow), newWindow);
g_signal_connect(newWebView, "run-as-modal", G_CALLBACK(webViewRunAsModal), newWindow);
g_signal_connect(newWebView, "close", G_CALLBACK(webViewClose), newWindow);
return GTK_WIDGET(newWebView);
}
static VALUE
WebView_set_settings(VALUE self, VALUE __v_settings)
{
WebKitWebSettings * settings; WebKitWebSettings * __orig_settings;
WebKitWebView *_self = ((WebKitWebView*)RVAL2GOBJ(self));
__orig_settings = settings = RVAL2GOBJ(__v_settings);
#line 262 "/home/ngl/Progetti/gtk-webkit-ruby/ext/webkit/webkit.cr"
webkit_web_view_set_settings(_self, settings);
return self;
}
StatusWidget::StatusWidget(Statusnet::Status status) {
GtkWidget *webkit = webkit_web_view_new();
//std::cout<<"creating statuswidget with text: "<<status.text<<std::endl;
WebKitWebView *view = WEBKIT_WEB_VIEW(webkit);
Gtk::Widget *webkit_mm = Glib::wrap(webkit);
WebKitWebSettings *webkitsettings = webkit_web_settings_new();
g_object_set(G_OBJECT(webkitsettings), "enable-default-context-menu", FALSE, NULL);
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webkit), webkitsettings);
webkit_web_view_load_string(WEBKIT_WEB_VIEW(webkit), this->parse(status).c_str(), NULL, NULL, "");
g_signal_connect(view, "navigation-policy-decision-requested", G_CALLBACK(&StatusWidget::navigation_policy_decision_requested_cb), view);
webkit_mm->set_size_request(10, 100);
this->add(*webkit_mm);
}
static void createBrowserWindow(const gchar *uri, WebKitSettings *webkitSettings)
{
GtkWidget *webView = webkit_web_view_new();
GtkWidget *mainWindow = browser_window_new(WEBKIT_WEB_VIEW(webView), NULL);
gchar *url = argumentToURL(uri);
if (webkitSettings) {
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView), webkitSettings);
g_object_unref(webkitSettings);
}
browser_window_load_uri(BROWSER_WINDOW(mainWindow), url);
g_free(url);
gtk_widget_grab_focus(webView);
gtk_widget_show(mainWindow);
}
void browser_apply_settings(Browser *b)
{
WebKitWebFrame *frame;
/* view */
if (show_scrollbars) {
gtk_scrolled_window_set_policy(b->UI.scrolled_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
} else {
frame = webkit_web_view_get_main_frame(b->UI.view);
g_signal_connect(G_OBJECT(frame), "scrollbars-policy-changed", G_CALLBACK(gtk_true), NULL);
gtk_scrolled_window_set_policy(b->UI.scrolled_window, GTK_POLICY_NEVER, GTK_POLICY_NEVER);
}
/* apply browser settings */
webkit_web_view_set_settings(b->UI.view, ripcurl->Global.webkit_settings);
/* statusbar */
gtk_misc_set_alignment(GTK_MISC(b->Statusbar.text), 0.0, 0.0);
gtk_misc_set_alignment(GTK_MISC(b->Statusbar.buffer), 1.0, 0.0);
gtk_misc_set_alignment(GTK_MISC(b->Statusbar.position), 1.0, 0.0);
gtk_misc_set_padding(GTK_MISC(b->Statusbar.text), 1.0, 2.0);
gtk_misc_set_padding(GTK_MISC(b->Statusbar.buffer), 1.0, 2.0);
gtk_misc_set_padding(GTK_MISC(b->Statusbar.position), 1.0, 2.0);
gtk_widget_modify_bg(GTK_WIDGET(b->UI.statusbar), GTK_STATE_NORMAL, &(ripcurl->Style.statusbar_bg));
gtk_widget_modify_fg(GTK_WIDGET(b->Statusbar.text), GTK_STATE_NORMAL, &(ripcurl->Style.statusbar_fg));
gtk_widget_modify_fg(GTK_WIDGET(b->Statusbar.buffer), GTK_STATE_NORMAL, &(ripcurl->Style.statusbar_fg));
gtk_widget_modify_fg(GTK_WIDGET(b->Statusbar.position), GTK_STATE_NORMAL, &(ripcurl->Style.statusbar_fg));
gtk_widget_modify_font(GTK_WIDGET(b->Statusbar.text), ripcurl->Style.font);
gtk_widget_modify_font(GTK_WIDGET(b->Statusbar.buffer), ripcurl->Style.font);
gtk_widget_modify_font(GTK_WIDGET(b->Statusbar.position), ripcurl->Style.font);
/* inputbar settings */
gtk_entry_set_inner_border(b->UI.inputbar, NULL);
gtk_entry_set_has_frame(b->UI.inputbar, FALSE);
gtk_editable_set_editable(GTK_EDITABLE(b->UI.inputbar), TRUE);
gtk_widget_modify_base(GTK_WIDGET(b->UI.inputbar), GTK_STATE_NORMAL, &(ripcurl->Style.inputbar_bg));
gtk_widget_modify_text(GTK_WIDGET(b->UI.inputbar), GTK_STATE_NORMAL, &(ripcurl->Style.inputbar_fg));
gtk_widget_modify_font(GTK_WIDGET(b->UI.inputbar), ripcurl->Style.font);
}
static void create_browser() {
browser->browser_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (browser->browser_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
browser->webview = webkit_web_view_new();
gtk_container_add(GTK_CONTAINER(browser->browser_window), browser->webview);
g_signal_connect (G_OBJECT (browser->webview), "load-progress-changed", G_CALLBACK (progress_change_cb), browser);
g_signal_connect (G_OBJECT (browser->webview), "load-committed", G_CALLBACK (load_commit_cb), browser);
g_signal_connect (G_OBJECT (browser->webview), "hovering-over-link", G_CALLBACK (link_hover_cb), browser);
WebKitWebSettings* settings = webkit_web_settings_new();
g_object_set(G_OBJECT(settings), "enable-private-browsing", FALSE, NULL);
g_object_set(G_OBJECT(settings), "enable-plugins", FALSE, NULL);
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(browser->webview), settings);
/* Translators: you may change the web address to get a localized page, if it exists */
webkit_web_view_open(WEBKIT_WEB_VIEW(browser->webview), _("http://images.google.com"));
}
void createBrowserWindow(const gchar *uri, WebKitSettings *webkitSettings)
{
GtkWidget *webView = webkit_web_view_new();
GtkWidget *mainWindow = browser_window_new(WEBKIT_WEB_VIEW(webView), NULL);
gtk_widget_set_sensitive(BROWSER_WINDOW(mainWindow)->backItem, FALSE);
gtk_widget_set_sensitive(BROWSER_WINDOW(mainWindow)->forwardItem, FALSE);
gchar *url = argumentToURL(uri);
gtk_window_set_title(GTK_WINDOW(mainWindow), "Cuprum Browser");
if (webkitSettings)
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView), webkitSettings);
browser_window_load_uri(BROWSER_WINDOW(mainWindow), url);
g_free(url);
//zgh gtk_widget_grab_focus(webView);
gtk_widget_show(mainWindow);
}
/* return the path to the output file, or NULL in case of error */
static gboolean
generate_pdf (MuMsg *msg, const char *str, GError **err)
{
GtkWidget *view;
WebKitWebFrame *frame;
WebKitWebSettings *settings;
WebKitLoadStatus status;
time_t started;
const int max_time = 3; /* max 3 seconds to download stuff */
settings = webkit_web_settings_new ();
g_object_set (G_OBJECT(settings),
"enable-scripts", FALSE,
"auto-load-images", TRUE,
"enable-plugins", FALSE, NULL);
view = webkit_web_view_new ();
/* to support cid: */
g_signal_connect (G_OBJECT(view), "resource-request-starting",
G_CALLBACK (on_resource_request_starting), msg);
webkit_web_view_set_settings (WEBKIT_WEB_VIEW(view), settings);
webkit_web_view_load_string (WEBKIT_WEB_VIEW(view),
str, "text/html", "utf-8", "");
g_object_unref (settings);
frame = webkit_web_view_get_main_frame (WEBKIT_WEB_VIEW(view));
if (!frame) {
g_set_error (err, 0, MU_ERROR, "cannot get web frame");
return FALSE;
}
started = time (NULL);
do {
status = webkit_web_view_get_load_status (WEBKIT_WEB_VIEW(view));
gtk_main_iteration_do (FALSE);
} while (status != WEBKIT_LOAD_FINISHED &&
(time(NULL) - started) <= max_time);
return print_to_pdf (frame, err);
}
static void testWebViewGroupSettings(Test* test, gconstpointer)
{
GRefPtr<WebKitWebViewGroup> viewGroup1 = adoptGRef(webkit_web_view_group_new("TestGroup1"));
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(viewGroup1.get()));
GRefPtr<WebKitSettings> newSettings = adoptGRef(webkit_settings_new_with_settings("enable-javascript", FALSE, nullptr));
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(newSettings.get()));
webkit_web_view_group_set_settings(viewGroup1.get(), newSettings.get());
g_assert(webkit_web_view_group_get_settings(viewGroup1.get()) == newSettings.get());
GRefPtr<WebKitWebView> webView1 = WEBKIT_WEB_VIEW(webkit_web_view_new_with_group(viewGroup1.get()));
GRefPtr<WebKitWebView> webView2 = WEBKIT_WEB_VIEW(webkit_web_view_new());
WebKitSettings* webView1Settings = webkit_web_view_get_settings(webView1.get());
WebKitSettings* webView2Settings = webkit_web_view_get_settings(webView2.get());
g_assert(webView1Settings != webView2Settings);
g_assert(webkit_settings_get_enable_javascript(webView1Settings) != webkit_settings_get_enable_javascript(webView2Settings));
webkit_web_view_set_settings(webView1.get(), webView2Settings);
g_assert(webkit_web_view_get_settings(webView1.get()) == webView2Settings);
g_assert(webkit_web_view_group_get_settings(webkit_web_view_get_group(webView1.get())) == webView2Settings);
}
static GtkWidget *
_webkit_web_view_new (OAuthAskAuthorizationDialog *self)
{
WebKitWebContext *context;
GtkWidget *view;
WebKitSettings *settings;
WebKitCookieManager *cookie_manager;
GFile *file;
char *cookie_filename;
context = webkit_web_context_get_default ();
view = webkit_web_view_new_with_context (context);
settings = webkit_settings_new ();
webkit_settings_set_enable_javascript (settings, TRUE);
webkit_settings_set_javascript_can_open_windows_automatically (settings, TRUE);
webkit_web_view_set_settings (WEBKIT_WEB_VIEW (view), settings);
file = gth_user_dir_get_file_for_write (GTH_DIR_CACHE, GTHUMB_DIR, "cookies", NULL);
cookie_filename = g_file_get_path (file);
cookie_manager = webkit_web_context_get_cookie_manager (context);
webkit_cookie_manager_set_accept_policy (cookie_manager, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
webkit_cookie_manager_set_persistent_storage (cookie_manager, cookie_filename, WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT);
webkit_web_context_set_cache_model (context, WEBKIT_CACHE_MODEL_DOCUMENT_BROWSER);
g_free (cookie_filename);
g_object_unref (file);
g_signal_connect (view,
"create",
G_CALLBACK (webkit_view_create_cb),
self);
g_signal_connect (view,
"ready-to-show",
G_CALLBACK (webkit_view_ready_to_show_cb),
self);
return view;
}
int main(int argc, char* argv[])
{
WebKitWebSettings *webkitSettings = 0;
const gchar **uriArguments = 0;
const GOptionEntry commandLineOptions[] =
{
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &uriArguments, 0, "[URL]" },
{ 0, 0, 0, 0, 0, 0, 0 }
};
gtk_init(&argc, &argv);
GOptionContext *context = g_option_context_new(0);
g_option_context_add_main_entries(context, commandLineOptions, 0);
g_option_context_add_group(context, gtk_get_option_group(TRUE));
webkitSettings = webkit_web_settings_new();
if (!addWebSettingsGroupToContext(context, webkitSettings)) {
g_object_unref(webkitSettings);
webkitSettings = 0;
}
GError *error = 0;
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_printerr("Cannot parse arguments: %s\n", error->message);
g_error_free(error);
g_option_context_free(context);
return 1;
}
g_option_context_free(context);
#ifdef SOUP_TYPE_PROXY_RESOLVER_DEFAULT
soup_session_add_feature_by_type(webkit_get_default_session(), SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
#else
const char *httpProxy = g_getenv("http_proxy");
if (httpProxy) {
SoupURI *proxyUri = soup_uri_new(httpProxy);
g_object_set(webkit_get_default_session(), SOUP_SESSION_PROXY_URI, proxyUri, NULL);
soup_uri_free(proxyUri);
}
#endif
WebKitWebView *webView;
GtkWidget *main_window = createWindow(&webView);
if (webkitSettings) {
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView), webkitSettings);
g_object_unref(webkitSettings);
}
const gchar *uri = (uriArguments ? uriArguments[0] : "http://www.google.com/");
gchar *fileURL = filenameToURL(uri);
webkit_web_view_load_uri(webView, fileURL ? fileURL : uri);
g_free(fileURL);
gtk_widget_grab_focus(GTK_WIDGET(webView));
gtk_widget_show_all(main_window);
gtk_main();
return 0;
}
int main( int argc,
char *argv[] )
{
/* GtkWidget is the storage type for widgets */
GtkWidget *window;
GtkWidget *menubar;
time_t now;
struct tm *tm;
GThread *gth = NULL; /* thread id */
gboolean run_flag = TRUE; /* used as exit flag for threads */
int i;
putenv("UBUNTU_MENUPROXY=");
//init_trees();
gdk_color_parse("#FFFF00", &color_yellow);
gdk_color_parse("#FFFFFF", &color_white);
gdk_color_parse("#404040", &color_grey);
gdk_color_parse("#00FF00", &color_green);
gdk_color_parse("#007700", &color_darkgreen);
gdk_color_parse("#0000FF", &color_blue);
gdk_color_parse("#FF0000", &color_red);
gdk_color_parse("#770000", &color_darkred);
gdk_color_parse("#000000", &color_black);
font = pango_font_description_from_string("Sans bold 12");
#ifdef WIN32
installation_dir = g_win32_get_package_installation_directory_of_module(NULL);
#else
gbr_init(NULL);
installation_dir = gbr_find_prefix(NULL);
#endif
program_path = argv[0];
current_directory[0] = 0;
if (current_directory[0] == 0)
strcpy(current_directory, ".");
conffile = g_build_filename(g_get_user_data_dir(), "judoproxy.ini", NULL);
/* create video download dir */
video_dir = g_build_filename(g_get_home_dir(), "rpivideos", NULL);
g_print("Video dir = %s\n", video_dir);
g_mkdir_with_parents(video_dir, 0755);
keyfile = g_key_file_new();
g_key_file_load_from_file(keyfile, conffile, 0, NULL);
now = time(NULL);
tm = localtime(&now);
current_year = tm->tm_year+1900;
srand(now); //srandom(now);
my_address = now + getpid()*10000;
gtk_init (&argc, &argv);
main_window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window), "JudoProxy");
gtk_widget_set_size_request(window, FRAME_WIDTH, FRAME_HEIGHT);
gchar *iconfile = g_build_filename(installation_dir, "etc", "judoproxy.png", NULL);
gtk_window_set_default_icon_from_file(iconfile, NULL);
g_free(iconfile);
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
main_vbox = gtk_grid_new();
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 1);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
gtk_widget_show(main_vbox);
/* menubar */
menubar = get_menubar_menu(window);
gtk_widget_show(menubar);
gtk_grid_attach(GTK_GRID(main_vbox), menubar, 0, 0, 1, 1);
gtk_widget_set_hexpand(menubar, TRUE);
/* judoka info */
//name_box = gtk_label_new("?");
//gtk_box_pack_start(GTK_BOX(main_vbox), name_box, FALSE, TRUE, 0);
//GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
//gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, TRUE, 0);
notebook = gtk_notebook_new();
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
gtk_widget_set_hexpand(notebook, TRUE);
//gtk_widget_set_vexpand(notebook, TRUE);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
/*
GtkWidget *camera_table = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(camera_table), 10);
gtk_grid_set_row_spacing(GTK_GRID(camera_table), 10);
*/
for (i = 0; i < NUM_TATAMIS; i++) {
gchar buf[32];
GtkWidget *data_table = gtk_grid_new();
connections[i].scrolled_window = data_table;
//connections[i].scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(connections[i].scrolled_window), 10);
snprintf(buf, sizeof(buf), "T%d [--]", i+1);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), connections[i].scrolled_window,
gtk_label_new(buf));
gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(_("Camera")), 0, 0, 2, 1);
gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(_("JudoTimer")), 4, 0, 2, 1);
GtkWidget *reload = gtk_button_new_with_label(_("Reload"));
gtk_grid_attach(GTK_GRID(data_table), reload, 0, 1, 1, 1);
connections[i].in_addr = gtk_entry_new();
connections[i].out_addr = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(connections[i].in_addr), 15);
gtk_entry_set_width_chars(GTK_ENTRY(connections[i].out_addr), 15);
gtk_grid_attach(GTK_GRID(data_table), connections[i].in_addr, 2, 0, 2, 1);
gtk_grid_attach(GTK_GRID(data_table), connections[i].out_addr, 6, 0, 2, 1);
gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(" "), 0, 1, 1, 1);
//gtk_container_add(GTK_CONTAINER(connections[i].scrolled_window), data_table);
g_signal_connect (connections[i].out_addr, "activate",
G_CALLBACK(enter_callback),
gint_to_ptr(i));
g_signal_connect (connections[i].in_addr, "activate",
G_CALLBACK(camera_ip_enter_callback),
gint_to_ptr(i));
#ifdef WEBKIT
g_signal_connect (reload, "clicked",
G_CALLBACK(reload_web),
gint_to_ptr(i));
#else
g_signal_connect (reload, "clicked",
G_CALLBACK(select_camera_video),
gint_to_ptr(i));
#endif
}
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
gtk_grid_attach_next_to(GTK_GRID(main_vbox), notebook, NULL, GTK_POS_BOTTOM, 1, 1);
progress_bar = gtk_progress_bar_new();
gtk_grid_attach_next_to(GTK_GRID(main_vbox), progress_bar, NULL, GTK_POS_BOTTOM, 1, 1);
GtkWidget *w = GTK_WIDGET(gtk_scrolled_window_new(NULL, NULL));
#ifdef WEBKIT
web_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
webkit_web_view_set_transparent(web_view, TRUE);
gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(web_view));
gtk_widget_set_vexpand(GTK_WIDGET(web_view), TRUE);
WebKitWebSettings *web_settings = webkit_web_settings_new();
//g_object_set(G_OBJECT(web_settings), "enable-java-applet", FALSE, NULL);
//g_object_set(G_OBJECT(web_settings), "enable-plugins", FALSE, NULL);
webkit_web_view_set_settings(web_view, web_settings);
gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(w), NULL, GTK_POS_BOTTOM, 1, 1);
gtk_widget_grab_focus(GTK_WIDGET(web_view));
//webkit_web_view_load_uri(web_view, "http://www.hs.fi");
webkit_web_view_load_uri(web_view, "http://www.quirksmode.org/html5/tests/video.html");
g_signal_connect(web_view, "download-requested", G_CALLBACK(download_req), NULL);
//g_signal_connect(web_view, "load-changed", G_CALLBACK(load_changed), NULL);
#else
/* HTML page */
html_page = create_html_page();
gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(html_page), NULL, GTK_POS_BOTTOM, 1, 1);
/* Video display */
camera_image = gtk_image_new();
gtk_widget_set_size_request(GTK_WIDGET(camera_image), 640, 360);
GtkWidget *event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(event_box), camera_image);
gtk_widget_set_events(event_box, gtk_widget_get_events(event_box) |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
/*GDK_POINTER_MOTION_MASK |*/
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK);
g_signal_connect(G_OBJECT(event_box),
"button_press_event",
G_CALLBACK(button_press_callback),
camera_image);
g_signal_connect(G_OBJECT(event_box),
"button_release_event",
G_CALLBACK(button_release_callback),
camera_image);
g_signal_connect(G_OBJECT(event_box),
"motion-notify-event",
G_CALLBACK(button_notify_callback),
camera_image);
gtk_widget_show(camera_image);
gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(event_box));
gtk_widget_set_vexpand(GTK_WIDGET(event_box), TRUE);
gtk_widget_set_hexpand(GTK_WIDGET(event_box), TRUE);
gtk_widget_set_vexpand(GTK_WIDGET(camera_image), TRUE);
gtk_widget_set_hexpand(GTK_WIDGET(camera_image), TRUE);
gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(w), NULL, GTK_POS_BOTTOM, 1, 1);
#endif
/* timers */
timer = g_timer_new();
gtk_widget_show_all(window);
set_preferences();
change_language(NULL, NULL, gint_to_ptr(language));
open_comm_socket();
scan_interfaces();
/* Create a bg thread using glib */
gpointer proxy_ssdp_thread(gpointer args);
g_snprintf(ssdp_id, sizeof(ssdp_id), "JudoProxy");
static gint run[NUM_CONNECTIONS];
for (i = 0; i < NUM_CONNECTIONS; i++) {
char tname[16];
run[i] = i;
sprintf(tname, "Connection%d", i);
gth = g_thread_new(tname,
(GThreadFunc)connection_thread,
&run[i]);
}
gth = g_thread_new("SSDP",
(GThreadFunc)proxy_ssdp_thread,
(gpointer)&run_flag);
gth = g_thread_new("CameraVideo",
camera_video,
(gpointer)&run_flag);
gth = gth; // make compiler happy
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
cursor = gdk_cursor_new(GDK_HAND2);
//gdk_window_set_cursor(GTK_WIDGET(main_window)->window, cursor);
//g_timeout_add(100, timeout_ask_for_data, NULL);
g_timeout_add(1000, check_table, NULL);
g_timeout_add(100, show_camera_video, NULL);
//g_idle_add(show_camera_video, NULL);
/* All GTK applications must have a gtk_main(). Control ends here
* and waits for an event to occur (like a key press or
* mouse event). */
gtk_main();
for (i = 0; i < NUM_CONNECTIONS; i++)
run[i] = -1;
run_flag = FALSE; /* flag threads to stop and exit */
//g_thread_join(gth); /* wait for thread to exit */
return 0;
}
static int init_setting(GtkWidget * window, GtkWidget * view)
{
gint root_x, root_y;
gint screen_width, screen_height;
/* Setting Window */
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(window), global_get("title"));
gtk_widget_set_size_request(GTK_WIDGET(window), 10, 10);
gtk_window_set_resizable(GTK_WINDOW(window), (gboolean)global_get("resizeable"));
gtk_window_set_decorated(GTK_WINDOW(window), (gboolean)global_get("border"));
if (gtk_window_get_resizable(GTK_WINDOW(window))) {
gtk_window_resize(GTK_WINDOW(window), (gint)global_get("width"), (gint)global_get("height"));
} else {
gtk_widget_set_size_request(GTK_WIDGET(window), (gint)global_get("width"), (gint)global_get("height"));
}
/* Move Window */
screen_get_size(&screen_width, &screen_height);
root_x = (screen_width - (gint)global_get("width")) / 2;
root_y = (screen_height - (gint)global_get("height")) / 2;
if ((gint)global_get("x") != 10000) root_x = (gint)global_get("x");
if ((gint)global_get("y") != 10000) root_y = (gint)global_get("y");
if (root_x < 0) root_x = screen_width + root_x;
if (root_y < 0) root_y = screen_height + root_y;
gtk_window_move(GTK_WINDOW(window), root_x, root_y);
/* Setting Icon */
if (g_file_test(global_get("icon"), G_FILE_TEST_EXISTS)) {
gtk_window_set_icon_from_file(GTK_WINDOW(window), global_get("icon"), NULL);
}
/* Fullscreen */
if ((gboolean)global_get("fullscreen")) af_window_set_fullscreen(TRUE);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(af_exit), NULL);
g_signal_connect(G_OBJECT(window), "window-state-event", G_CALLBACK(window_onstatechange), NULL);
/* Setting Webkit */
WebKitWebSettings *setting = webkit_web_view_get_settings (WEBKIT_WEB_VIEW(view));
g_object_set(G_OBJECT(setting), "default-encoding", global_get("encode"), NULL);
g_object_set(G_OBJECT(setting), "enable-webgl", TRUE, NULL);
//g_object_set(G_OBJECT(view), "self-scrolling", TRUE, NULL);
g_object_set(G_OBJECT(setting), "default-font-family", "SimSun", NULL);
g_object_set(G_OBJECT(setting), "monospace-font-family", "SimSun", NULL);
g_object_set(G_OBJECT(setting), "sans-serif-font-family", "SimSun", NULL);
g_object_set(G_OBJECT(setting), "serif-font-family", "SimSun", NULL);
g_object_set(G_OBJECT(setting), "cursive-font-family", "SimSun", NULL);
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(view), setting);
g_signal_connect(WEBKIT_WEB_VIEW(view), "window-object-cleared", G_CALLBACK(js_callback), NULL);
g_signal_connect(WEBKIT_WEB_VIEW(view), "close-web-view", G_CALLBACK(webview_onclose), NULL);
return 0;
}
gboolean bind_getkey (GtkNotebook *notebook, GdkEventKey *event)
{
CreamTabbed *obj;
gboolean ret = TRUE;
global.browser.mode = BindMode;
obj = get_current_creamtabbed ();
if (bind_buffer == NULL)
bind_buffer = g_string_new ("");
switch (event->keyval)
{
case GDK_Escape:
{
GtkWidget *content = cream_view_get_content (CREAM_VIEW (obj->creamview));
if (MODULE_IS_WEB_VIEW (content))
{
WebKitWebSettings *settings = module_web_view_get_settings (MODULE_WEB_VIEW (content));
g_object_set (settings, "enable-caret-browsing", FALSE, NULL);
webkit_web_view_set_settings (WEBKIT_WEB_VIEW (content), settings);
}
echo (obj, "");
gtk_widget_grab_focus (GTK_WIDGET (obj));
global.browser.mode = BindMode;
break;
}
case GDK_Insert:
{
GtkWidget *content = cream_view_get_content (CREAM_VIEW (obj->creamview));
if (MODULE_IS_WEB_VIEW (content))
{
WebKitWebSettings *settings = module_web_view_get_settings (MODULE_WEB_VIEW (content));
g_object_set (settings, "enable-caret-browsing", TRUE, NULL);
webkit_web_view_set_settings (WEBKIT_WEB_VIEW (content), settings);
}
echo (obj, "-- CARET --");
gtk_widget_grab_focus (GTK_WIDGET (obj));
global.browser.mode = InsertMode;
break;
}
case GDK_colon:
if (!gtk_entry_get_text (GTK_ENTRY (obj->inputbox)))
{
echo (obj, ":");
gtk_widget_grab_focus (obj->inputbox);
gtk_entry_set_position (GTK_ENTRY (obj->inputbox), -1);
global.browser.mode = CmdMode;
}
break;
case GDK_slash:
if (!gtk_entry_get_text (GTK_ENTRY (obj->inputbox)))
{
echo (obj, "/");
gtk_widget_grab_focus (obj->inputbox);
gtk_entry_set_position (GTK_ENTRY (obj->inputbox), -1);
global.browser.mode = CmdMode;
}
break;
default:
if (event->string != NULL)
bind_buffer = g_string_append (bind_buffer, event->string);
ret = FALSE;
break;
}
if (ret)
{
g_string_free (bind_buffer, TRUE);
bind_buffer = NULL;
}
else
ret = bind_parse_buffer (obj);
return ret;
}
static void messageview_show_cb(GObject *obj, gpointer msgview,
MsgInfo *msginfo, gboolean all_headers)
{
MessageView *messageview = NULL;
MimeInfo *mimeinfo, *partial;
FILE *msg_file, *input = NULL;
gchar *html_buf = NULL;
size_t n_size;
#if defined(USE_WEBKITGTK)
WebKitWebSettings *settings = NULL;
#elif defined(USE_GTKHTML)
#else
#error "Not Implemented"
#endif
SYLPF_START_FUNC;
g_return_if_fail(msgview != NULL);
messageview = (MessageView*)msgview;
g_return_if_fail(messageview != NULL);
SYLPF_OPTION.is_show_attach_tab = SYLPF_GET_RC_SHOW_ATTACH_TAB;
if (SYLPF_OPTION.is_show_attach_tab == 0) {
gtk_notebook_set_current_page(GTK_NOTEBOOK(messageview->notebook), 0);
SYLPF_RETURN;
}
if (SYLPF_OPTION.html_view == NULL) {
#if defined(USE_WEBKITGTK)
SYLPF_OPTION.html_view = (WebKitWebView*)create_htmlview(GTK_NOTEBOOK(messageview->notebook));
#elif defined(USE_GTKHTML)
SYLPF_OPTION.html_view = create_htmlview(GTK_NOTEBOOK(messageview->notebook));
#endif
}
mimeinfo = procmime_scan_message(msginfo);
msg_file = procmsg_open_message(msginfo);
partial = mimeinfo;
while (partial && partial->mime_type != MIME_TEXT_HTML) {
partial = procmime_mimeinfo_next(partial);
}
if (partial && partial->mime_type == MIME_TEXT_HTML) {
partial->mime_type = MIME_TEXT;
input = procmime_get_text_content(partial, msg_file, NULL);
html_buf = calloc(partial->size+1, 1);
n_size = fread(html_buf, partial->size, 1, input);
#if defined(USE_WEBKITGTK)
settings = webkit_web_view_get_settings(SYLPF_OPTION.html_view);
g_object_set(G_OBJECT(settings), ENABLE_IMAGES, SYLPF_OPTION.image_flag, NULL);
g_object_set(G_OBJECT(settings), ENABLE_SCRIPTS, SYLPF_OPTION.script_flag, NULL);
g_object_set(G_OBJECT(settings), ENABLE_PRIVATE_BROWSING, SYLPF_OPTION.private_flag, NULL);
g_object_set(G_OBJECT(settings), DEFAULT_FONT_SIZE, SYLPF_OPTION.font_size, NULL);
webkit_web_view_set_settings(SYLPF_OPTION.html_view, settings);
webkit_web_view_load_string(SYLPF_OPTION.html_view, html_buf, NULL, NULL, "");
#elif defined(USE_GTKHTML)
gtk_html_load_from_string(GTK_HTML(SYLPF_OPTION.html_view), html_buf, -1);
#endif
if (SYLPF_OPTION.switch_tab_flag != FALSE) {
gtk_notebook_set_current_page(GTK_NOTEBOOK(messageview->notebook), 2);
}
fclose(input);
free(html_buf);
} else {
gtk_notebook_set_current_page(GTK_NOTEBOOK(messageview->notebook), 0);
}
SYLPF_END_FUNC;
}
/**
* Initializes WebKit
*
* Initializes the WebKit HTML rendering engine. Creates a GTK scrollpane widget
* and embeds WebKitWebView into it.
*/
static GtkWidget *
liferea_webkit_new (LifereaHtmlView *htmlview)
{
WebKitWebView *view;
GtkWidget *scrollpane;
scrollpane = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (scrollpane),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC
);
gtk_scrolled_window_set_shadow_type (
GTK_SCROLLED_WINDOW (scrollpane),
GTK_SHADOW_IN
);
/** Create HTML widget and pack it into the scrolled window */
view = WEBKIT_WEB_VIEW (webkit_web_view_new ());
webkit_web_view_set_settings (view, settings);
gtk_container_add (GTK_CONTAINER (scrollpane), GTK_WIDGET (view));
/** Pass LifereaHtmlView into the WebKitWebView object */
g_object_set_data (
G_OBJECT (view),
"htmlview",
htmlview
);
/** Connect signal callbacks */
g_signal_connect (
view,
"notify::title",
G_CALLBACK (liferea_webkit_title_changed),
view
);
g_signal_connect (
view,
"load-progress-changed",
G_CALLBACK (liferea_webkit_progress_changed),
view
);
g_signal_connect (
view,
"hovering-over-link",
G_CALLBACK (liferea_webkit_on_url),
view
);
g_signal_connect (
view,
"navigation-policy-decision-requested",
G_CALLBACK (liferea_webkit_link_clicked),
view
);
g_signal_connect (
view,
"new-window-policy-decision-requested",
G_CALLBACK (liferea_webkit_new_window_requested),
view
);
g_signal_connect (
view,
"populate-popup",
G_CALLBACK (liferea_webkit_on_menu),
view
);
g_signal_connect (
view,
"notify::uri",
G_CALLBACK (liferea_webkit_location_changed),
view
);
g_signal_connect (
view,
"console-message",
G_CALLBACK (liferea_webkit_javascript_message),
view
);
g_signal_connect (
view,
"create-web-view",
G_CALLBACK (webkit_create_web_view),
view
);
gtk_widget_show (GTK_WIDGET (view));
return scrollpane;
}
