static VbResult normal_zoom(Client *c, const NormalCmdInfo *info)
{
float step = 0.1, level, count;
WebKitWebView *view = c->webview;
/* check if the second key is allowed */
if (!strchr("iIoOz", info->key2)) {
return RESULT_ERROR;
}
count = info->count ? (float)info->count : 1.0;
/* zz reset zoom to it's default zoom level */
if (info->key2 == 'z') {
webkit_settings_set_zoom_text_only(webkit_web_view_get_settings(view), FALSE);
webkit_web_view_set_zoom_level(view, c->config.default_zoom / 100.0);
return RESULT_COMPLETE;
}
level= webkit_web_view_get_zoom_level(view);
/* calculate the new zoom level */
if (info->key2 == 'i' || info->key2 == 'I') {
level += ((float)count * step);
} else {
level -= ((float)count * step);
}
/* apply the new zoom level */
webkit_settings_set_zoom_text_only(webkit_web_view_get_settings(view), VB_IS_LOWER(info->key2));
webkit_web_view_set_zoom_level(view, level);
return RESULT_COMPLETE;
}
void
resize(GtkWidget *w, GtkAllocation *a, Client *c) {
double zoom;
if(c->zoomed)
return;
zoom = webkit_web_view_get_zoom_level(c->view);
if(a->width * a->height < 300 * 400 && zoom != 0.2)
webkit_web_view_set_zoom_level(c->view, 0.2);
else if(zoom != 1.0)
webkit_web_view_set_zoom_level(c->view, 1.0);
}
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;
}
/* ghtml_set_zoom */
void ghtml_set_zoom(GtkWidget * widget, gdouble zoom)
{
GHtml * ghtml;
ghtml = g_object_get_data(G_OBJECT(widget), "ghtml");
webkit_web_view_set_zoom_level(WEBKIT_WEB_VIEW(ghtml->view), zoom);
}
/* ghtml_zoom_reset */
void ghtml_zoom_reset(GtkWidget * widget)
{
GHtml * ghtml;
ghtml = g_object_get_data(G_OBJECT(widget), "ghtml");
webkit_web_view_set_zoom_level(WEBKIT_WEB_VIEW(ghtml->view), 1.0);
}
static int gtkWebBrowserSetZoomAttrib(Ihandle* ih, const char* value)
{
int zoom;
if (iupStrToInt(value, &zoom))
webkit_web_view_set_zoom_level((WebKitWebView*)ih->handle, (float)zoom/100.0f);
return 0;
}
/**
* Change zoom level of the HTML scrollpane
*/
static void
liferea_webkit_change_zoom_level (GtkWidget *scrollpane, gfloat zoom_level)
{
WebKitWebView *view;
view = WEBKIT_WEB_VIEW (gtk_bin_get_child (GTK_BIN (scrollpane)));
webkit_web_view_set_zoom_level (view, zoom_level);
}
static void handleZoomLock(int value)
{
if(value > 0)
webkit_web_view_zoom_in(g_web_view);
else if(value < 0)
webkit_web_view_zoom_out(g_web_view);
else
webkit_web_view_set_zoom_level(g_web_view, g_default_scale );
}
static void zoomOut(gboolean fullContentsZoom)
{
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
if (!view)
return;
webkit_web_view_set_full_content_zoom(view, fullContentsZoom);
gfloat currentZoom = webkit_web_view_get_zoom_level(view);
webkit_web_view_set_zoom_level(view, currentZoom / zoomMultiplierRatio);
}
void
html_decrease_size(Html *html)
{
gfloat zoom;
g_return_if_fail(IS_HTML (html));
zoom = webkit_web_view_get_zoom_level(html->webview);
zoom /= 1.2;
webkit_web_view_set_zoom_level(html->webview,zoom);
}
static int default_zoom(Client *c, const char *name, DataType type, void *value, void *data)
{
/* Store the percent value in the client config. */
c->config.default_zoom = *(int*)value;
/* Apply the default zoom to the webview. */
webkit_settings_set_zoom_text_only(webkit_web_view_get_settings(c->webview), FALSE);
webkit_web_view_set_zoom_level(c->webview, c->config.default_zoom / 100.0);
return CMD_SUCCESS;
}
static JSValueRef textZoomOutCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
if (!view)
return JSValueMakeUndefined(context);
gfloat currentZoom = webkit_web_view_get_zoom_level(view);
webkit_web_view_set_zoom_level(view, currentZoom / zoomMultiplierRatio);
return JSValueMakeUndefined(context);
}
void browser_zoom(Browser *b, int mode)
{
switch (mode) {
case ZOOM_IN:
webkit_web_view_zoom_in(b->UI.view);
break;
case ZOOM_OUT:
webkit_web_view_zoom_out(b->UI.view);
break;
default:
webkit_web_view_set_zoom_level(b->UI.view, 1.0);
break;
}
}
void wxWebViewWebKit::SetWebkitZoom(float level)
{
webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW(web_view), level);
}
static void web_zoom_100(GtkWidget* item, WebKitWebView* webView) {
gfloat zoom = webkit_web_view_get_zoom_level(webView);
if (zoom != 1.0) {
webkit_web_view_set_zoom_level(webView, 1.0);
}
}
int main(int argc, char* argv[])
{
// Initialize GTK+
gtk_init(&argc, &argv);
gdk_threads_init();
GtkWidget *main_window;
GdkWindow *gdk_window;
createDrawContext(&main_window, &gdk_window);
// Create a browser instance
WebKitWebView *webView = WEBKIT_WEB_VIEW(webkit_web_view_new());
// make sure the background of the main window is black plz
GdkColor blaaack;
gdk_color_parse("#000000", &blaaack);
gtk_widget_modify_bg(main_window, GTK_STATE_NORMAL, &blaaack);
// Put the browser area into the main window
gtk_container_add(GTK_CONTAINER(main_window), GTK_WIDGET(webView));
// necessary for ensuring positioning relative to xscreensaver-demo is right
gtk_widget_show_all(main_window);
// Set up callbacks so that if either the main window or the browser instance is
// closed, the program will exit
g_signal_connect(main_window, "destroy", G_CALLBACK(destroyWindow), NULL);
g_signal_connect(main_window, "delete-event", G_CALLBACK(destroyWindow), NULL);
// transparent background so we dont have any white flashes
webkit_web_view_set_transparent(webView, true);
int height;
int width;
gdk_window_get_geometry(gdk_window, NULL, NULL, &width, &height, NULL);
if (height < 480 && width < 640) {
// make the tiny preview windows look reasonable
webkit_web_view_set_full_content_zoom(webView, true);
webkit_web_view_set_zoom_level(webView, 0.4);
}
// set up some webkit settings
WebKitWebSettings *settings = webkit_web_view_get_settings(webView);
g_object_set (G_OBJECT(settings), "enable-webgl", true, NULL);
// accelerated-compositing chokes on my machine, but maybe its my shitty nvidia drivers
g_object_set (G_OBJECT(settings), "enable-accelerated-compositing", false, NULL);
// select tag and format url
wordexp_t exp_result;
wordexp(CONFIG_PATH, &exp_result, 0);
printf("Loading tags file at %s\n", exp_result.we_wordv[0]);
char* tags_path = exp_result.we_wordv[0];
char url[MAX_URL_LENGTH];
char tags[MAX_NUMBER_TAGS][MAX_TAG_LENGTH];
int tags_length = 0;
FILE* tags_file;
if (tags_path == NULL || (tags_file = fopen(tags_path, "r")) == NULL) {
printf("No tag file found. using defaults\n");
int default_tags_length = sizeof(DEFAULT_TAGS) / sizeof(char*);
for (int i = 0; i < default_tags_length; ++i) {
printf("%d\n", i);
strcpy(tags[i], DEFAULT_TAGS[i]);
}
tags_length = default_tags_length;
} else {
int i = 0;
printf("Iterating through file\n");
while (i < MAX_NUMBER_TAGS && fgets(tags[i], sizeof(tags[0]), tags_file)) {
tags[i][strlen(tags[i]) - 1] = '\0';
printf("Got %s!\n", tags[i]);
++i;
}
tags_length = i;
}
printf("%d tags found. selecting one.\n", tags_length);
srand(time(0));
int index = rand() % tags_length;
printf("%d is our index...\n", index);
printf("%s selected!\n", tags[index]);
sprintf(url, URL_FORMAT, tags[index]);
printf("Loading %s\n", url);
webkit_web_view_load_uri(webView, url);
// Make sure that when the browser area becomes visible, it will get mouse
// and keyboard events
gtk_widget_grab_focus(GTK_WIDGET(webView));
// hit our callback whenever load-status changes
g_signal_connect(G_OBJECT(webView), "notify::load-status", G_CALLBACK(load_status_cb), &url);
g_signal_connect(G_OBJECT(webView), "load-error", G_CALLBACK(load_error_cb), &url);
// Run the main GTK+ event loop
gtk_main();
return 0;
}
static void zoomFitCallback(BrowserWindow *window)
{
gdouble zoomLevel = 1.0;
webkit_web_view_set_zoom_level(window->webView, zoomLevel);
}
void
browser_dialog_open (const gchar *plug_in_binary)
{
GtkWidget *window;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *toolbar;
GtkWidget *paned;
GtkWidget *scrolled;
GtkToolItem *item;
GtkAction *action;
DialogData data = { 720, 560, 240, TRUE, 1.0 };
gimp_ui_init (plug_in_binary, TRUE);
gimp_get_data (GIMP_HELP_BROWSER_DIALOG_DATA, &data);
/* the dialog window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), _("GIMP Help Browser"));
gtk_window_set_role (GTK_WINDOW (window), plug_in_binary);
gtk_window_set_default_size (GTK_WINDOW (window), data.width, data.height);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
window_set_icons (window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
ui_manager = ui_manager_new (window);
toolbar = gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar");
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
gtk_widget_show (toolbar);
item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0);
gtk_widget_show (GTK_WIDGET (item));
action = gtk_ui_manager_get_action (ui_manager,
"/ui/help-browser-popup/forward");
gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action);
g_object_notify (G_OBJECT (action), "tooltip");
button_next = GTK_WIDGET (item);
item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0);
gtk_widget_show (GTK_WIDGET (item));
action = gtk_ui_manager_get_action (ui_manager,
"/ui/help-browser-popup/back");
gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action);
g_object_notify (G_OBJECT (action), "tooltip");
button_prev = GTK_WIDGET (item);
item =
GTK_TOOL_ITEM (gtk_ui_manager_get_widget (ui_manager,
"/help-browser-toolbar/space"));
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
gtk_tool_item_set_expand (item, TRUE);
/* the horizontal paned */
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0);
gtk_widget_show (paned);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add1 (GTK_PANED (paned), scrolled);
gtk_paned_set_position (GTK_PANED (paned), data.paned_position);
sidebar = scrolled;
if (data.show_index)
gtk_widget_show (sidebar);
tree_view = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
gtk_container_add (GTK_CONTAINER (scrolled), tree_view);
gtk_widget_show (tree_view);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1,
NULL,
gtk_cell_renderer_text_new (),
"text", 1,
NULL);
g_signal_connect (tree_view, "row-activated",
G_CALLBACK (row_activated),
NULL);
/* HTML view */
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (main_vbox);
gtk_paned_pack2 (GTK_PANED (paned), main_vbox, TRUE, TRUE);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrolled, 300, 200);
gtk_box_pack_start (GTK_BOX (main_vbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show (scrolled);
view = webkit_web_view_new ();
webkit_web_view_set_maintains_back_forward_list (WEBKIT_WEB_VIEW (view),
TRUE);
gtk_container_add (GTK_CONTAINER (scrolled), view);
gtk_widget_show (view);
g_signal_connect (view, "realize",
G_CALLBACK (view_realize),
NULL);
g_signal_connect (view, "unrealize",
G_CALLBACK (view_unrealize),
NULL);
g_signal_connect (view, "popup-menu",
G_CALLBACK (view_popup_menu),
NULL);
g_signal_connect (view, "button-press-event",
G_CALLBACK (view_button_press),
NULL);
g_signal_connect (view, "key-press-event",
G_CALLBACK (view_key_press),
NULL);
webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW (view), data.zoom);
g_signal_connect (view, "title-changed",
G_CALLBACK (title_changed),
window);
g_signal_connect (view, "load-started",
G_CALLBACK (load_started),
NULL);
g_signal_connect (view, "load-finished",
G_CALLBACK (load_finished),
NULL);
gtk_widget_grab_focus (view);
g_signal_connect (window, "unmap",
G_CALLBACK (dialog_unmap),
paned);
update_actions ();
/* Searchbar */
searchbar = build_searchbar ();
gtk_box_pack_start (GTK_BOX (main_vbox), searchbar, FALSE, FALSE, 0);
}
gboolean
key_web_view(GtkWidget *widget, GdkEvent *event, gpointer data)
{
struct Client *c = (struct Client *)data;
gdouble dx, dy;
gchar *f;
gfloat z;
WebKitWebContext *wc = webkit_web_view_get_context(WEBKIT_WEB_VIEW(c->web_view));
if (event->type == GDK_KEY_PRESS)
{
if (((GdkEventKey *)event)->state & GDK_MOD1_MASK)
{
switch (((GdkEventKey *)event)->keyval)
{
case GDK_KEY_q: /* close window (left hand) */
gtk_widget_destroy(c->win);
return TRUE;
case GDK_KEY_w: /* home (left hand) */
f = ensure_uri_scheme(home_uri);
webkit_web_view_load_uri(WEBKIT_WEB_VIEW(c->web_view), f);
g_free(f);
return TRUE;
case GDK_KEY_e: /* new tab (left hand) */
f = ensure_uri_scheme(home_uri);
client_new(f);
g_free(f);
return TRUE;
case GDK_KEY_r: /* reload (left hand) */
webkit_web_view_reload_bypass_cache(WEBKIT_WEB_VIEW(
c->web_view));
return TRUE;
case GDK_KEY_d: /* download manager (left hand) */
gtk_widget_show_all(dm.win);
return TRUE;
case GDK_KEY_2: /* search forward (left hand) */
case GDK_KEY_n: /* search forward (maybe both hands) */
search(c, 1);
return TRUE;
case GDK_KEY_3: /* search backward (left hand) */
search(c, -1);
return TRUE;
case GDK_KEY_l: /* location (BOTH hands) */
gtk_widget_grab_focus(c->location);
return TRUE;
case GDK_KEY_k: /* initiate search (BOTH hands) */
gtk_widget_grab_focus(c->location);
gtk_entry_set_text(GTK_ENTRY(c->location), "/");
gtk_editable_set_position(GTK_EDITABLE(c->location), -1);
return TRUE;
case GDK_KEY_c: /* reload trusted certs (left hand) */
trust_user_certs(wc);
return TRUE;
}
}
/* navigate backward (left hand) */
else if (((GdkEventKey *)event)->keyval == GDK_KEY_F2)
{
webkit_web_view_go_back(WEBKIT_WEB_VIEW(c->web_view));
return TRUE;
}
/* navigate forward (left hand) */
else if (((GdkEventKey *)event)->keyval == GDK_KEY_F3)
{
webkit_web_view_go_forward(WEBKIT_WEB_VIEW(c->web_view));
return TRUE;
}
else if (((GdkEventKey *)event)->keyval == GDK_KEY_Escape)
{
webkit_web_view_stop_loading(WEBKIT_WEB_VIEW(c->web_view));
gtk_level_bar_set_value(GTK_LEVEL_BAR(c->progress), 0);
}
}
else if (event->type == GDK_BUTTON_PRESS)
{
switch (((GdkEventButton *)event)->button)
{
case 2:
if (c->hover_uri != NULL)
{
client_new(c->hover_uri);
return TRUE;
}
break;
case 8:
webkit_web_view_go_back(WEBKIT_WEB_VIEW(c->web_view));
return TRUE;
case 9:
webkit_web_view_go_forward(WEBKIT_WEB_VIEW(c->web_view));
return TRUE;
}
}
else if (event->type == GDK_SCROLL)
{
if (((GdkEventScroll *)event)->state & GDK_MOD1_MASK ||
((GdkEventScroll *)event)->state & GDK_CONTROL_MASK)
{
gdk_event_get_scroll_deltas(event, &dx, &dy);
z = webkit_web_view_get_zoom_level(WEBKIT_WEB_VIEW(c->web_view));
z += -dy * 0.1;
z = dx != 0 ? global_zoom : z;
webkit_web_view_set_zoom_level(WEBKIT_WEB_VIEW(c->web_view), z);
return TRUE;
}
}
return FALSE;
}
WebKitWebView *
client_new(const gchar *uri)
{
struct Client *c;
WebKitWebContext *wc;
gchar *f;
if (uri != NULL && cooperative_instances && !cooperative_alone)
{
write(cooperative_pipe_fp, uri, strlen(uri));
write(cooperative_pipe_fp, "\n", 1);
return NULL;
}
c = malloc(sizeof(struct Client));
if (!c)
{
fprintf(stderr, __NAME__": fatal: malloc failed\n");
exit(EXIT_FAILURE);
}
c->hover_uri = NULL;
c->win = NULL;
if (embed != 0)
{
c->win = gtk_plug_new(embed);
if (!gtk_plug_get_embedded(GTK_PLUG(c->win)))
{
fprintf(stderr, __NAME__": Can't plug-in to XID %ld.\n", embed);
gtk_widget_destroy(c->win);
c->win = NULL;
embed = 0;
}
}
if (c->win == NULL)
{
c->win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_wmclass(GTK_WINDOW(c->win), __NAME__, __NAME_CAPITALIZED__);
}
gtk_window_set_default_size(GTK_WINDOW(c->win), 800, 600);
g_signal_connect(G_OBJECT(c->win), "destroy", G_CALLBACK(client_destroy), c);
gtk_window_set_title(GTK_WINDOW(c->win), __NAME__);
c->web_view = webkit_web_view_new();
wc = webkit_web_view_get_context(WEBKIT_WEB_VIEW(c->web_view));
webkit_web_view_set_zoom_level(WEBKIT_WEB_VIEW(c->web_view), global_zoom);
g_signal_connect(G_OBJECT(c->web_view), "notify::title",
G_CALLBACK(changed_title), c);
g_signal_connect(G_OBJECT(c->web_view), "notify::uri",
G_CALLBACK(changed_uri), c);
g_signal_connect(G_OBJECT(c->web_view), "notify::estimated-load-progress",
G_CALLBACK(changed_load_progress), c);
g_signal_connect(G_OBJECT(c->web_view), "create",
G_CALLBACK(client_new_request), NULL);
g_signal_connect(G_OBJECT(c->web_view), "close",
G_CALLBACK(client_destroy_request), c);
g_signal_connect(G_OBJECT(c->web_view), "decide-policy",
G_CALLBACK(decide_policy), NULL);
g_signal_connect(G_OBJECT(c->web_view), "key-press-event",
G_CALLBACK(key_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "button-press-event",
G_CALLBACK(key_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "scroll-event",
G_CALLBACK(key_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "mouse-target-changed",
G_CALLBACK(hover_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "web-process-crashed",
G_CALLBACK(crashed_web_view), c);
if (!initial_wc_setup_done)
{
if (accepted_language[0] != NULL)
webkit_web_context_set_preferred_languages(wc, accepted_language);
g_signal_connect(G_OBJECT(wc), "download-started",
G_CALLBACK(download_handle_start), NULL);
trust_user_certs(wc);
initial_wc_setup_done = TRUE;
}
if (user_agent != NULL)
g_object_set(G_OBJECT(webkit_web_view_get_settings(WEBKIT_WEB_VIEW(c->web_view))),
"user-agent", user_agent, NULL);
c->location = gtk_entry_new();
g_signal_connect(G_OBJECT(c->location), "key-press-event",
G_CALLBACK(key_location), c);
/* XXX Progress bars don't work/look as intended anymore. Level bars
* are a dirty workaround (kind of). */
c->progress = gtk_level_bar_new();
gtk_level_bar_set_value(GTK_LEVEL_BAR(c->progress), 0);
gtk_widget_set_size_request(c->progress, 100, -1);
c->top_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(c->top_box), c->location, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(c->top_box), c->progress, FALSE, FALSE, 0);
c->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(c->vbox), c->top_box, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c->vbox), c->web_view, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(c->win), c->vbox);
gtk_widget_grab_focus(c->web_view);
gtk_widget_show_all(c->win);
if (uri != NULL)
{
f = ensure_uri_scheme(uri);
webkit_web_view_load_uri(WEBKIT_WEB_VIEW(c->web_view), f);
g_free(f);
}
clients++;
return WEBKIT_WEB_VIEW(c->web_view);
}
void
cmd_zoom_level() {
webkit_web_view_set_zoom_level (uzbl.gui.web_view, uzbl.behave.zoom_level);
}
void document_webkit_zoom_restore(Documentable *doc)
{
g_return_if_fail(doc);
Document_WebkitDetails *docdet = DOCUMENT_WEBKIT_GET_PRIVATE(doc);
webkit_web_view_set_zoom_level (docdet->help_view, 1);
}
void
html_reset_size(Html *html)
{
g_return_if_fail(IS_HTML (html));
webkit_web_view_set_zoom_level(html->webview,1.0);
}
void wxWebViewWebKit::SetWebkitZoom(float level)
{
webkit_web_view_set_zoom_level(m_web_view, level);
}
static void zoomOutCallback(BrowserWindow *window)
{
gdouble zoomLevel = webkit_web_view_get_zoom_level(window->webView) / zoomStep;
webkit_web_view_set_zoom_level(window->webView, zoomLevel);
}
