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