--- /dev/null
+diff --git a/.gitignore b/.gitignore
+index 8c08dc0..092909f 100644
+--- a/.gitignore
++++ b/.gitignore
+@@ -1,4 +1,5 @@
+ uzbl-core
++local.mk
+ *.o
+ *.lo
+ *.pyc
+@@ -6,3 +7,4 @@ uzbl-core
+ *~
+ tags
+ sandbox
++/build
+diff --git a/AUTHORS b/AUTHORS
+index b3ce2e2..22d3c9b 100644
+--- a/AUTHORS
++++ b/AUTHORS
+@@ -46,6 +46,7 @@ In alphabetical order:
+ Gregor Uhlenheuer (kongo2002) <kongo2002@googlemail.com> - uzbl vim syntax & related files
+ Helmut Grohne (helmut) - move void **ptr to union, various fixes
+ Henri Kemppainen (DuClare) <email is akarinotengoku AT THE DOMAIN OF gmail.com> - many contributions, mostly old handler code
++ Håkan Jerning - uzbl-tabbed: autosave_session patch
+ Igor Bogomazov - mouse ptr events
+ Jake Probst <jake.probst@gmail.com> - uzbl_tabbed: multiline tablist, new window opening patches
+ James Campos (aeosynth) <james.r.campos@gmail.com> - Re-orderable gtk notebook tabs in uzbl-tabbed
+diff --git a/Makefile b/Makefile
+index a11fc8d..ba74e57 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,25 +1,53 @@
++# Create a local.mk file to store default local settings to override the
++# defaults below.
++include $(wildcard local.mk)
++
+ # packagers, set DESTDIR to your "package directory" and PREFIX to the prefix you want to have on the end-user system
+ # end-users who build from source: don't care about DESTDIR, update PREFIX if you want to
+ # RUN_PREFIX : what the prefix is when the software is run. usually the same as PREFIX
+-PREFIX?=/usr/local
+-INSTALLDIR?=$(DESTDIR)$(PREFIX)
+-DOCDIR?=$(INSTALLDIR)/share/uzbl/docs
+-RUN_PREFIX?=$(PREFIX)
++PREFIX ?= /usr/local
++INSTALLDIR ?= $(DESTDIR)$(PREFIX)
++DOCDIR ?= $(INSTALLDIR)/share/uzbl/docs
++RUN_PREFIX ?= $(PREFIX)
++
++ENABLE_WEBKIT2 ?= no
++ENABLE_GTK3 ?= auto
++
++PYTHON=python3
++PYTHONV=$(shell $(PYTHON) --version | sed -n /[0-9].[0-9]/p)
++COVERAGE=$(shell which coverage)
++
++# --- configuration ends here ---
++
++ifeq ($(ENABLE_WEBKIT2),auto)
++ENABLE_WEBKIT2 := $(shell pkg-config --exists webkit2gtk-3.0 && echo yes)
++endif
+
+-# use GTK3-based webkit when it is available
+-USE_GTK3 = $(shell pkg-config --exists gtk+-3.0 webkitgtk-3.0 && echo 1)
++ifeq ($(ENABLE_GTK3),auto)
++ENABLE_GTK3 := $(shell pkg-config --exists gtk+-3.0 && echo yes)
++endif
+
+-ifeq ($(USE_GTK3),1)
+- REQ_PKGS += gtk+-3.0 webkitgtk-3.0 javascriptcoregtk-3.0
+- CPPFLAGS = -DG_DISABLE_DEPRECATED -DGTK_DISABLE_DEPRECATED
++ifeq ($(ENABLE_WEBKIT2),yes)
++REQ_PKGS += 'webkit2gtk-3.0 >= 1.2.4' javascriptcoregtk-3.0
++CPPFLAGS += -DUSE_WEBKIT2
++# WebKit2 requires GTK3
++ENABLE_GTK3 := yes
++else
++ifeq ($(ENABLE_GTK3),yes)
++REQ_PKGS += 'webkitgtk-3.0 >= 1.2.4' javascriptcoregtk-3.0
+ else
+- REQ_PKGS += gtk+-2.0 webkit-1.0 javascriptcoregtk-1.0
+- CPPFLAGS =
++REQ_PKGS += 'webkit-1.0 >= 1.2.4' javascriptcoregtk-1.0
++endif
+ endif
+
+-# --- configuration ends here ---
++ifeq ($(ENABLE_GTK3),yes)
++REQ_PKGS += gtk+-3.0
++CPPFLAGS += -DG_DISABLE_DEPRECATED -DGTK_DISABLE_DEPRECATED
++else
++REQ_PKGS += gtk+-2.0
++endif
+
+-REQ_PKGS += libsoup-2.4 gthread-2.0 glib-2.0
++REQ_PKGS += 'libsoup-2.4 >= 2.30' gthread-2.0 glib-2.0
+
+ ARCH:=$(shell uname -m)
+
+@@ -33,10 +61,11 @@ LDLIBS:=$(shell pkg-config --libs $(REQ_PKGS) x11)
+
+ CFLAGS += -std=c99 $(PKG_CFLAGS) -ggdb -W -Wall -Wextra -pedantic -pthread
+
+-SRC = $(wildcard src/*.c)
++SRC = $(wildcard src/*.c)
+ HEAD = $(wildcard src/*.h)
+ OBJ = $(foreach obj, $(SRC:.c=.o), $(notdir $(obj)))
+ LOBJ = $(foreach obj, $(SRC:.c=.lo), $(notdir $(obj)))
++PY = $(wildcard uzbl/*.py uzbl/plugins/*.py)
+
+ all: uzbl-browser
+
+@@ -46,7 +75,13 @@ ${OBJ}: ${HEAD}
+
+ uzbl-core: ${OBJ}
+
+-uzbl-browser: uzbl-core
++uzbl-browser: uzbl-core uzbl-event-manager
++
++build: ${PY}
++ $(PYTHON) setup.py build
++
++.PHONY: uzbl-event-manager
++uzbl-event-manager: build
+
+ # the 'tests' target can never be up to date
+ .PHONY: tests
+@@ -61,38 +96,43 @@ tests: ${LOBJ} force
+ $(CC) -shared -Wl ${LOBJ} -o ./tests/libuzbl-core.so
+ cd ./tests/; $(MAKE)
+
++test-event-manager: force
++ ${PYTHON} -m unittest discover tests/event-manager -v
++
++coverage-event-manager: force
++ ${PYTHON} ${COVERAGE} erase
++ ${PYTHON} ${COVERAGE} run -m unittest discover tests/event-manager
++ ${PYTHON} ${COVERAGE} html ${PY}
++ # Hmm, I wonder what a good default browser would be
++ uzbl-browser htmlcov/index.html
++
+ test-uzbl-core: uzbl-core
+ ./uzbl-core --uri http://www.uzbl.org --verbose
+
+ test-uzbl-browser: uzbl-browser
+ ./bin/uzbl-browser --uri http://www.uzbl.org --verbose
+
+-test-uzbl-core-sandbox: uzbl-core
+- make DESTDIR=./sandbox RUN_PREFIX=`pwd`/sandbox/usr/local install-uzbl-core
+- make DESTDIR=./sandbox RUN_PREFIX=`pwd`/sandbox/usr/local install-example-data
+- cp -np ./misc/env.sh ./sandbox/env.sh
++test-uzbl-core-sandbox: sandbox uzbl-core sandbox-install-uzbl-core sandbox-install-example-data
+ . ./sandbox/env.sh && uzbl-core --uri http://www.uzbl.org --verbose
+ make DESTDIR=./sandbox uninstall
+ rm -rf ./sandbox/usr
+
+-test-uzbl-browser-sandbox: uzbl-browser
+- make DESTDIR=./sandbox RUN_PREFIX=`pwd`/sandbox/usr/local install-uzbl-browser
+- make DESTDIR=./sandbox RUN_PREFIX=`pwd`/sandbox/usr/local install-example-data
+- cp -np ./misc/env.sh ./sandbox/env.sh
+- -. ./sandbox/env.sh && uzbl-event-manager restart -avv
++test-uzbl-browser-sandbox: sandbox uzbl-browser sandbox-install-uzbl-browser sandbox-install-example-data
++ . ./sandbox/env.sh && ${PYTHON} -S `which uzbl-event-manager` restart -navv &
+ . ./sandbox/env.sh && uzbl-browser --uri http://www.uzbl.org --verbose
+- . ./sandbox/env.sh && uzbl-event-manager stop -ivv
++ . ./sandbox/env.sh && ${PYTHON} -S `which uzbl-event-manager` stop -vv -o /dev/null
+ make DESTDIR=./sandbox uninstall
+ rm -rf ./sandbox/usr
+
+-test-uzbl-tabbed-sandbox: uzbl-browser
+- make DESTDIR=./sandbox RUN_PREFIX=`pwd`/sandbox/usr/local install-uzbl-browser
+- make DESTDIR=./sandbox RUN_PREFIX=`pwd`/sandbox/usr/local install-uzbl-tabbed
+- make DESTDIR=./sandbox RUN_PREFIX=`pwd`/sandbox/usr/local install-example-data
+- cp -np ./misc/env.sh ./sandbox/env.sh
+- -. ./sandbox/env.sh && uzbl-event-manager restart -avv
++test-uzbl-tabbed-sandbox: sandbox uzbl-browser sandbox-install-uzbl-browser sandbox-install-uzbl-tabbed sandbox-install-example-data
++ . ./sandbox/env.sh && ${PYTHON} -S `which uzbl-event-manager` restart -avv
+ . ./sandbox/env.sh && uzbl-tabbed
+- . ./sandbox/env.sh && uzbl-event-manager stop -ivv
++ . ./sandbox/env.sh && ${PYTHON} -S `which uzbl-event-manager` stop -avv
++ make DESTDIR=./sandbox uninstall
++ rm -rf ./sandbox/usr
++
++test-uzbl-event-manager-sandbox: sandbox uzbl-browser sandbox-install-uzbl-browser sandbox-install-example-data
++ . ./sandbox/env.sh && ${PYTHON} -S `which uzbl-event-manager` restart -navv
+ make DESTDIR=./sandbox uninstall
+ rm -rf ./sandbox/usr
+
+@@ -102,18 +142,44 @@ clean:
+ find ./examples/ -name "*.pyc" -delete
+ cd ./tests/; $(MAKE) clean
+ rm -rf ./sandbox/
++ $(PYTHON) setup.py clean
+
+ strip:
+ @echo Stripping binary
+ @strip uzbl-core
+ @echo ... done.
+
++SANDBOXOPTS=\
++ DESTDIR=./sandbox\
++ RUN_PREFIX=`pwd`/sandbox/usr/local\
++ PYINSTALL_EXTRA='--prefix=./sandbox/usr/local --install-scripts=./sandbox/usr/local/bin'
++
++sandbox: misc/env.sh
++ mkdir -p sandbox/${PREFIX}/lib64
++ cp -p misc/env.sh sandbox/env.sh
++ test -e sandbox/${PREFIX}/lib || ln -s lib64 sandbox/${PREFIX}/lib
++
++sandbox-install-uzbl-browser:
++ make ${SANDBOXOPTS} install-uzbl-browser
++
++sandbox-install-uzbl-tabbed:
++ make ${SANDBOXOPTS} install-uzbl-tabbed
++
++sandbox-install-uzbl-core:
++ make ${SANDBOXOPTS} install-uzbl-core
++
++sandbox-install-event-manager:
++ make ${SANDBOXOPTS} install-event-manager
++
++sandbox-install-example-data:
++ make ${SANDBOXOPTS} install-example-data
++
+ install: install-uzbl-core install-uzbl-browser install-uzbl-tabbed
+
+ install-dirs:
+ [ -d "$(INSTALLDIR)/bin" ] || install -d -m755 $(INSTALLDIR)/bin
+
+-install-uzbl-core: all install-dirs
++install-uzbl-core: uzbl-core install-dirs
+ install -d $(INSTALLDIR)/share/uzbl/
+ install -d $(DOCDIR)
+ install -m644 docs/* $(DOCDIR)/
+@@ -123,8 +189,7 @@ install-uzbl-core: all install-dirs
+ install -m755 uzbl-core $(INSTALLDIR)/bin/uzbl-core
+
+ install-event-manager: install-dirs
+- sed "s#^PREFIX = .*#PREFIX = '$(RUN_PREFIX)'#" < bin/uzbl-event-manager > $(INSTALLDIR)/bin/uzbl-event-manager
+- chmod 755 $(INSTALLDIR)/bin/uzbl-event-manager
++ $(PYTHON) setup.py install --prefix=$(PREFIX) --install-scripts=$(INSTALLDIR)/bin $(PYINSTALL_EXTRA)
+
+ install-uzbl-browser: install-dirs install-uzbl-core install-event-manager
+ sed 's#^PREFIX=.*#PREFIX=$(RUN_PREFIX)#' < bin/uzbl-browser > $(INSTALLDIR)/bin/uzbl-browser
+diff --git a/README b/README
+index b124fb4..5241aba 100644
+--- a/README
++++ b/README
+@@ -252,18 +252,42 @@ The following commands are recognized:
+ - Open the print dialog.
+ * `include <file>`
+ - Read contents of `<file>` and interpret as a set of `uzbl` commands.
+-* `show_inspector`
+- - Show the WebInspector
++* `inspector <show | hide | coord <x> <y> | node <node-spec>>`
++ - Control the inspector. The `coord` command coordinates are relative to the
++ viewport, not the page. The `node` subcommand requires webkitgtk >=
++ 1.3.17.
++* `spell_checker <ignore <word>... | learn <word>... | autocorrect <word> | guesses <word>>`
++ - Control the spell checker. Requires webkitgtk >= 1.5.1.
+ * `add_cookie <domain> <path> <name> <value> <scheme> <expires>`
+ - Adds a new cookie to the cookie jar
+ * `delete_cookie <domain> <path> <name> <value> [<scheme> <expires>]`
+ - Deletes a matching cookie from the cookie jar. scheme and expire time
+- is currently not considered when matching.
++ is currently not considered when matching.
+ * `clear_cookies`
+ - Clears all cookies from the cookie jar
+ * `download <uri> [<destination path>]`
+ - Starts a download using the given uri. A destination file path can be given
+ to specify where the download should be written to.
++* `auth <uniqueid> <username> <password>`
++ - Authenticate as `<username>` with `<password>` for the previously issued
++ challenge with the id `<uniqueid>`. authenticating for a invalid id or one
++ expired one has no effect.
++* `snapshot <path>`
++ - Saves an image of the visible page as a PNG to the given path. Only available
++ with webkitgtk >= 1.9.6. This is not in webkit2gtk.
++* `load <string> <uri> [<baseuri>]`
++ - Load a string as text/html with the given uri. If given, all links will be
++ assumed relative to baseuri. Requires webkit2gtk >= 1.9.90.
++* `save [<format> [<path>]]`
++ - Saves the current page to a file in a given format (currently only "mhtml"
++ is supported). Requires webkit2gtk >= 1.9.90.
++* `remove_all_db`
++ - Removes all of the web databases from the current database directory path.
++* `plugin_refresh`
++ - Refreshes the plugin database. Requires webkitgtk >= 1.3.8.
++* `plugin_toggle [<plugin name> [<plugin name>...]]`
++ - Toggles whether the plugins named as arguments are enabled. No arguments is
++ interpreted as "all plugins". Requires webkitgtk >= 1.3.8.
+
+ ### VARIABLES AND CONSTANTS
+
+@@ -283,8 +307,10 @@ file).
+
+ * `uri`: The URI of the current page. (callback: load the uri)
+ * `verbose`: Controls the verbosity printed to `stdout`.
++* `inject_text`: Inject an text string, navigating to the URI "about:blank" and
++ rendering the text string given. Only available in webkit2gtk.
+ * `inject_html`: Inject an HTML string, navigating to the URI "about:blank" and
+- rendering the HTML sting given.
++ rendering the HTML string given.
+ * `geometry`: Geometry and position of the Uzbl window. Format is
+ "<width>x<height>+<x-offset>+<y-offset>".
+ * `keycmd`: Holds the input buffer (callback: update input buffer).
+@@ -333,11 +359,16 @@ file).
+ * `useragent`: The User-Agent to send to the browser, expands variables in its
+ definition.
+ * `accept_languages`: The Accept-Language header to send with HTTP requests.
++* `transparent`: If set to 1, the background of the view will be transparent
++ (default 0).
++* `view_mode`: The view mode for webkit. One of: "windowed", "floating",
++ "fullscreen", "maximized", or "minimized". Requires webkitgtk >= 1.3.4.
+ * `zoom_level`: The factor by which elements in the page are scaled with respect
+ to their original size. Setting this will resize the currently displayed page.
+ * `zoom_type`: Whether to use "full-content" zoom (defaults to true). With
+ full-content zoom on, all page content, not just text, is zoomed. When
+- full-content zoom is off, only the text of a page is zoomed.
++ full-content zoom is off, only the text of a page is zoomed. This is
++ unavailable with webkit2gtk. Use `zoom_text_only` instead.
+ * `font_size`: The default font size.
+ * `default_font_family`: The default font family used to display text.
+ * `monospace_font_family`: The default font family used to display monospace
+@@ -349,7 +380,6 @@ file).
+ * `fantasy_font_family`: The default Fantasy font family used to display text.
+ * `monospace_size`: The default size of monospaced font (default 1).
+ * `minimum_font_size`: The minimum font size used to display text (default 1).
+-* `enable_pagecache`: Enable the webkit pagecache (it caches rendered pages for a speedup when you go back or forward in history) (default 0).
+ * `enable_plugins`: Disable embedded plugin objects (default 0).
+ * `enable_scripts`: Disable embedded scripting languages (default 0).
+ * `autoload_images`: Automatically load images (default 1).
+@@ -360,25 +390,109 @@ file).
+ `en_CA` or `pt_BR`) to be used for spell checking, separated by commas.
+ Defaults to the value returned by `gtk_get_default_language`.
+ * `enable_private`: Whether to enable private browsing mode (default 0).
++* `cookie_policy`: If set to 0, all cookies are accepted, if set to 1, all
++ cookies are rejected, and 2 rejects third party cookies (default 0).
+ * `print_backgrounds`: Print background images? (default 0).
+ * `stylesheet_uri`: Use this to override the pagelayout with a custom
+ stylesheet.
+ * `resizable_text_areas`: Whether text areas can be resized (default 0).
+ * `default_encoding`: The default text encoding (default "iso-8859-1").
+-* `current_encoding`: This can be set to force a text encoding.
++* `custom_encoding`: This can be set to force a text encoding. (Used to be
++ `current_encoding` which is now read-only).
+ * `enforce_96_dpi`: Enforce a resolution of 96 DPI (default 1).
++* `editable`: Whether the page can be edited or not (default 0).
+ * `caret_browsing`: Whether the caret is enabled in the text portion of pages
+ (default 0).
+ * `enable_cross_file_access`: Whether a page loaded from a `file://` URI can
+ access the contents of other `file://` URIs. (default 0).
+ * `follow_hint_keys`: keys for keyboard-based navigation and link
+- highlighting
++ highlighting
+ * `handle_multi_click`: If set to 1, event handlers attached to `2Button*`
+- and `3Button*` bindings will only be used instead of the default actions in
+- WebKit (default 0).
++ and `3Button*` bindings will only be used instead of the default actions in
++ WebKit (default 0).
+ * `ssl_ca_file`: File that contains CA certificates.
+ * `ssl_verify`: If set to 1, uzbl won't connect to "https" url unless it can
+ validate certificate presented by remote server against `ssl_ca_file`.
++* `enable_builtin_auth`: Enable WebKits builtin authentication handler
++* `enable_java_applet`: If set to 1, support for Java <applet> tags will be
++ enabled (default 1).
++* `enable_database`: If set to 1, support for HTML5 client-side SQL databases
++ will be enabled (default 1).
++* `enable_local_storage`: If set to 1, websites will be able to store data
++ locally (default 1).
++* `enable_pagecache`: If set to 1, uzbl will store previously visited pages for
++ faster access (the cache is local to each uzbl instance) (default 0).
++* `enable_offline_app_cache`: If set to 1, web applications may be cached locally
++ for offline use (default 1).
++* `enable_universal_file_access`: If set to 1, allow `file://` URIs to access
++ all pages (default 0).
++* `enable_hyperlink_auditing`: If set to 1, the `ping` attribute on anchors will
++ be supported (default 0).
++* `zoom_step`: The change in the zoon level when zooming (default 0.1).
++* `auto_resize_window`: If set to 1, allow web pages to change window dimensions
++ (default 0).
++* `enable_spatial_navigation`: If set to 1, the arrow keys in `Ins` mode will
++ navigate between form elements (default 0).
++* `editing_behavior`: When set to 0, emulate Mac behavior in text fields, 1
++ for Windows behavior, and 2 for *nix behavior (the default).
++* `enable_tab_cycle`: If set to 1, the `Tab` key cycles between elements on
++ the page (default 1).
++* `default_context_menu`: If set to 0, do not cause context menus to appear when
++ right clicking (default 1).
++* `enable_site_workarounds`: If set to 1, enable filters to help unbreak
++ certain websites (default 0).
++* `javascript_clipboard`: If set to 1, JavaScript may access the clipboard
++ (default 0). Requires webkitgtk >= 1.3.0.
++* `javascript_dom_paste`: If set to 1, JavaScript will able to paste from the
++ clipboard (default 0).
++* `enable_frame_flattening`: If set to 1, flatten all frames into a single
++ page to become one scrollable page (default 0). Requires webkitgtk >= 1.3.5.
++* `enable_fullscreen`: If set to 1, Mozilla-style fullscreening will be
++ available (default 0). Requires webkitgtk >= 1.3.8
++* `enable_dns_prefetch`: If set to 1, domain names will be prefetched
++ (default 1). Private browsing does *not* affect this value. Requires
++ webkitgtk >= 1.3.13.
++* `display_insecure_content`: If set to 1, non-HTTPS content will be displayed
++ on HTTPS pages (default 1). Requires webkitgtk >= 1.11.13.
++* `run_insecure_content`: If set to 1, non-HTTPS content will be allowed to run
++ on HTTPS pages (default 1). Requires webkitgtk >= 1.11.13.
++* `maintain_history`: If set to 1, the back/forward list will be kept. (default
++ 1).
++* `enable_webgl`: If set to 1, WebGL support will be enabled (default 0).
++ Requires webkitgtk >= 1.3.14.
++* `local_storage_path`: Where to store local databases (default
++ $XDG_DATA_HOME/webkit/databases/). Requires webkit >= 1.5.2.
++* `enable_webaudio`: If set to 1, allows JavaScript to generate audio
++ directly (default 0). Requires webkit >= 1.7.5.
++* `enable_3d_acceleration`: If set to 1, the GPU will be used to render
++ animations and 3D CSS transformations. Requires webkitgtk >= 1.7.90.
++* `zoom_text_only`: If set to 1, only text will be zoomed (default 0). Requires
++ webkit2gtk >= 1.7.91.
++* `enable_smooth_scrolling`: If set to 1, scrolling the page will be smoothed
++ (default 0). Requires webkitgtk >= 1.9.0.
++* `enable_inline_media`: If set to 1, inline playback of media is allowed,
++ otherwise, only full-screen playback is allowed (default 1). Requires
++ webkitgtk >= 1.9.3.
++* `require_click_to_play`: If set to 1, playback of media requires user
++ interaction before playing, otherwise, media will be allowed to autoplay
++ (default 0). Requires webkitgtk >= 1.9.3.
++* `enable_css_shaders`: If set to 1, CSS shaders will be enabled (default 0).
++ Requires webkitgtk >= 1.11.1.
++* `enable_media_stream`: If set to 1, web pages will be able to access the
++ local video and audio input devices (default 0). Requires webkitgtk >= 1.11.1.
++* `cache_model`: The cache model of webkit. Valid values:
++ "document_viewer" (no caching; low memory; usage: single local file),
++ "web_browser" (heavy caching; faster; usage: general browsing),
++ "document_browser" (moderate caching; usage: series of local files)
++ (default "web_browser").
++* `app_cache_size`: The maximum size of the application cache (in bytes)
++ (default UINT_MAX (no quota)). Changing the variable clears the cache.
++ Requires webkitgtk >= 1.3.13.
++* `web_database_directory`: The directory where web databases are stored.
++ (default is under $XDG_DATA_HOME).
++* `web_database_quota`: The default quota for web databases. (default 5MB).
++* `profile_js`: Sets whether to profile JavaScript code.
++* `profile_timeline`: Sets whether to profile the timeline.
+
+ #### Constants (not dumpable or writeable)
+
+@@ -396,6 +510,13 @@ file).
+ - overridable with cmdline arg
+ - in GtkSocket mode, this is a random number to prevent name clashes
+ * `PID`: The process ID of this Uzbl instance.
++* `current_encoding`: The current encoding of the web page.
++* `inspected_uri`: The URI that is being inspected. Requires webkitgtk >=
++ 1.3.17.
++* `app_cache_directory`: The directory webkit uses to store its cache.
++ Requires webkitgtk >= 1.3.13.
++* `plugin_list`: A JSON list of objects describing the available plugins.
++ Requires webkitgtk >= 1.3.8.
+
+ ### VARIABLE EXPANSION AND COMMAND / JAVASCRIPT SUBSTITUTION
+
+@@ -514,10 +635,10 @@ access to the following environment variables:
+ * `$UZBL_SOCKET`: The filename of the Unix socket being used, if any.
+ * `$UZBL_URI`: The URI of the current page.
+ * `$UZBL_TITLE`: The current page title.
++* `$UZBL_PRIVATE`: Set if uzbl is in "private browsing mode", unset otherwise.
+
+-Handler scripts (`download_handler`, `cookie_handler`, `scheme_handler`,
+-`request_handler`, and `authentication_handler`) are called with special
+-arguments:
++Handler scripts (`download_handler`, `scheme_handler`, and `request_handler`)
++are called with special arguments:
+
+ * download handler
+
+@@ -532,16 +653,6 @@ arguments:
+ that the file should be saved to. A download handler using WebKit's internal
+ downloader can just echo this path and exit when this argument is present.
+
+-* cookie handler
+-
+- - `$1 GET/PUT`: Whether a cookie should be sent to the server (`GET`) or
+- stored by the browser (`PUT`).
+- - `$2 scheme`: Either `http` or `https`.
+- - `$3 host`: If current page URL is `www.example.com/somepage`, this could be
+- something else than `example.com`, eg advertising from another host.
+- - `$4 path`: The request address path.
+- - `$5 data`: The cookie data. Only included for `PUT` requests.
+-
+ * scheme handler
+
+ - `$1 URI` of the page to be navigated to
+@@ -550,13 +661,6 @@ arguments:
+
+ - `$1 URI` of the resource which is being requested
+
+-* authentication handler:
+-
+- - `$1`: authentication zone unique identifier
+- - `$2`: domain part of URL that requests authentication
+- - `$3`: authentication realm
+- - `$4`: FALSE if this is the first attempt to authenticate, TRUE otherwise
+-
+ ### Formfiller.sh
+
+ Example config entries for formfiller script
+@@ -584,47 +688,33 @@ after closing the editor, it will load the data into the formfields. The temp
+ file is removed
+
+ ### HTTP/BASIC AUTHENTICATION
++HTTP auth can be handled in two different ways. Using the builtin auth dialog
++in WebKit or by dispatching the work to a external script.
+
+-You can use the authentication_handler variable to denote how http
+-authentication should be handled.
+-If this variable is:
+-
+-* not set or empty: use webkit internal auth dialog
+-* a valid handler (i.e. {sh,sync}_spawn correct_script), use this handler
+-* innvalid handler (spawn, some other command, uses script that does not
+- print anything): skip authentication.
+-
+-Example:
++To use the builtin auth dialog set `enable_builtin_auth` to 1. With this set
++you'll get a basic GTK+ prompt for username/password when trying to access a
++protected site.
+
+- set authentication_handler = sync_spawn /patch/to/your/script
++Whenever authentication is needed the `AUTHENTICATE` event will be sent, this
++is what you would use to hook up a custom authentication system. This event
++will be sent even when using the bultin dialog so remember to disable that if
++adding a dialog of your own.
+
+-Script will be executed on each authentication request.
+-It will receive four auth-related parameters:
++The `AUTHENTICATE` event has four arguments
++ * a unique identifier to be used in the exchange
++ * domain part of URL that requests authentication
++ * authentication realm
++ * the empty string for the first attempt and "retrying" for further attempts
+
+- $1 authentication zone unique identifier (may be used as 'key')
+- $2 domain part of URL that requests authentication
+- $3 authentication realm
+- $4 FALSE if this is the first attempt to authenticate, TRUE otherwise
++After this event has been sent the request is paused until credentials are
++provided. This is done using the `auth` command e.g:
+
+-Script is expected to print exactly two lines of text on stdout (that means
+-its output must contain exactly two '\n' bytes).
+-The first line contains username, the second one - password.
+-If authentication fails, script will be executed again (with $4 = TRUE).
+-Non-interactive scripts should handle this case and do not try to
+-authenticate again to avoid loops. If number of '\n' characters in scripts
+-output does not equal 2, authentication will fail.
+-That means 401 error will be displayed and uzbl won't try to authenticate anymore.
++ `auth "uniqueid" "alice" "wonderland"`
+
+-The simplest example of authentication handler script is:
++A super simple setup that will always try to authenticate with the same password
++could look like this. (assuming aliases from the example configuration)
+
+-#!/bin/sh
+-[ "$4" == "TRUE ] && exit
+-echo alice
+-echo wonderland
+-
+-This script tries to authenticate as user alice with password wonderland once
+-and never retries authentication.
+-See examples for more sofisticated, interactive authentication handler.
++@on_event AUTHENTICATE auth "%1" "alice" "wonderland"
+
+ ### WINDOW MANAGER INTEGRATION
+
+@@ -657,11 +747,6 @@ The EM allows:
+ * Many fine-grained events (`hover_over_link`, `key_press`, `key_release`,..)
+ * See example `uzbl-event-manager`.
+
+-**Note**: Cookie events are sent in addition to (optionally) being handled by
+- the cookie handler (set by the cookie_handler var). If using a handler it will
+- take precedence before the internal state configured by (add|delete)_cookie
+- commands.
+-
+ Events have this format:
+
+ EVENT [uzbl_instance_name] EVENT_NAME event_details
+@@ -687,14 +772,18 @@ Events have this format:
+ loaded. `uri` is the URI of the page being loaded.
+ * `EVENT [uzbl_instance_name] LOAD_START uri`: A change of the page has been
+ requested. `uri` is the current URI; the one being departed.
+-* `EVENT [uzbl_instance_name] LOAD_FINISHED uri`: Loading has finished for the
++* `EVENT [uzbl_instance_name] LOAD_FINISH uri`: Loading has finished for the
+ page at `uri`.
+ * `EVENT [uzbl_instance_name] LOAD_ERROR uri reason_of_error`: The URI `uri`
+ could not be loaded for the reason described in `reason_of_error`.
+ * `EVENT [uzbl_instance_name] LOAD_PROGRESS percentage` : While the page is
+ loading, gives the `percentage` of the page that has finished loading.
++* `EVENT [uzbl_instance_name] REQUEST_QUEUED uri`: http resource gets
++ enqueued
+ * `EVENT [uzbl_instance_name] REQUEST_STARTING uri`: http resource gets
+ requested
++* `EVENT [uzbl_instance_name] REQUEST_FINISHED uri`: http resource has finished
++ loading
+ * `EVENT [uzbl_instance_name] TITLE_CHANGED title_name`: When the title of the
+ page (and hence maybe, the window title) changed. `title_name` is the new
+ title.
+@@ -743,6 +832,8 @@ Events have this format:
+ be a unix-timestamp or empty
+ * `EVENT [uzbl_instance_name] DELETE_COOKIE domain path name value scheme expire`:
+ When a cookie was deleted. arguments as ADD_COOKIE
++* `EVENT [uzbl_instance_name] AUTHENTICATE uniqueid host realm retry`: When a
++ request requires authentication. authentication is done by calling `auth`
+
+ Events/requests which the EM and its plugins listens for
+
+diff --git a/bin/uzbl-browser b/bin/uzbl-browser
+index fb9a368..4381050 100755
+--- a/bin/uzbl-browser
++++ b/bin/uzbl-browser
+@@ -67,9 +67,9 @@ fi
+ # uzbl-event-manager will exit if one is already running.
+ # we could also check if its pid file exists to avoid having to spawn it.
+ DAEMON_SOCKET="$XDG_CACHE_HOME"/uzbl/event_daemon
+-#if [ ! -f "$DAEMON_SOCKET".pid ]
+-#then
++if [ ! -f "$DAEMON_SOCKET".pid ]
++then
+ ${UZBL_EVENT_MANAGER:-uzbl-event-manager -va start}
+-#fi
++fi
+
+ exec uzbl-core "$@" ${config_file:+--config "$config_file"} --connect-socket $DAEMON_SOCKET
+diff --git a/bin/uzbl-event-manager b/bin/uzbl-event-manager
+index 56253ef..221fa73 100755
+--- a/bin/uzbl-event-manager
++++ b/bin/uzbl-event-manager
+@@ -1,1011 +1,3 @@
+-#!/usr/bin/env python2
+-
+-# Event Manager for Uzbl
+-# Copyright (c) 2009-2010, Mason Larobina <mason.larobina@gmail.com>
+-# Copyright (c) 2009, Dieter Plaetinck <dieter@plaetinck.be>
+-#
+-# This program is free software: you can redistribute it and/or modify
+-# it under the terms of the GNU General Public License as published by
+-# the Free Software Foundation, either version 3 of the License, or
+-# (at your option) any later version.
+-#
+-# This program is distributed in the hope that it will be useful,
+-# but WITHOUT ANY WARRANTY; without even the implied warranty of
+-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-# GNU General Public License for more details.
+-#
+-# You should have received a copy of the GNU General Public License
+-# along with this program. If not, see <http://www.gnu.org/licenses/>.
+-
+-'''
+-
+-E V E N T _ M A N A G E R . P Y
+-===============================
+-
+-Event manager for uzbl written in python.
+-
+-'''
+-
+-import atexit
+-import imp
+-import logging
+-import os
+-import sys
+-import time
+-import weakref
+-import re
+-import errno
+-from collections import defaultdict
+-from functools import partial
+-from glob import glob
+-from itertools import count
+-from optparse import OptionParser
+-from select import select
+-from signal import signal, SIGTERM, SIGINT, SIGKILL
+-from socket import socket, AF_UNIX, SOCK_STREAM, error as socket_error
+-from traceback import format_exc
+-
+-
+-def xdghome(key, default):
+- '''Attempts to use the environ XDG_*_HOME paths if they exist otherwise
+- use $HOME and the default path.'''
+-
+- xdgkey = "XDG_%s_HOME" % key
+- if xdgkey in os.environ.keys() and os.environ[xdgkey]:
+- return os.environ[xdgkey]
+-
+- return os.path.join(os.environ['HOME'], default)
+-
+-# `make install` will put the correct value here for your system
+-PREFIX = '/usr/local/'
+-
+-# Setup xdg paths.
+-DATA_DIR = os.path.join(xdghome('DATA', '.local/share/'), 'uzbl/')
+-CACHE_DIR = os.path.join(xdghome('CACHE', '.cache/'), 'uzbl/')
+-
+-# Define some globals.
+-SCRIPTNAME = os.path.basename(sys.argv[0])
+-
+-logger = logging.getLogger(SCRIPTNAME)
+-
+-
+-def get_exc():
+- '''Format `format_exc` for logging.'''
+- return "\n%s" % format_exc().rstrip()
+-
+-
+-def expandpath(path):
+- '''Expand and realpath paths.'''
+- return os.path.realpath(os.path.expandvars(path))
+-
+-
+-def ascii(u):
+- '''Convert unicode strings into ascii for transmission over
+- ascii-only streams/sockets/devices.'''
+- return u.encode('utf-8')
+-
+-
+-def daemonize():
+- '''Daemonize the process using the Stevens' double-fork magic.'''
+-
+- logger.info('entering daemon mode')
+-
+- try:
+- if os.fork():
+- os._exit(0)
+-
+- except OSError:
+- logger.critical('failed to daemonize', exc_info=True)
+- sys.exit(1)
+-
+- os.chdir('/')
+- os.setsid()
+- os.umask(0)
+-
+- try:
+- if os.fork():
+- os._exit(0)
+-
+- except OSError:
+- logger.critical('failed to daemonize', exc_info=True)
+- sys.exit(1)
+-
+- if sys.stdout.isatty():
+- sys.stdout.flush()
+- sys.stderr.flush()
+-
+- devnull = '/dev/null'
+- stdin = file(devnull, 'r')
+- stdout = file(devnull, 'a+')
+- stderr = file(devnull, 'a+', 0)
+-
+- os.dup2(stdin.fileno(), sys.stdin.fileno())
+- os.dup2(stdout.fileno(), sys.stdout.fileno())
+- os.dup2(stderr.fileno(), sys.stderr.fileno())
+-
+- logger.info('entered daemon mode')
+-
+-
+-def make_dirs(path):
+- '''Make all basedirs recursively as required.'''
+-
+- try:
+- dirname = os.path.dirname(path)
+- if not os.path.isdir(dirname):
+- logger.debug('creating directories %r', dirname)
+- os.makedirs(dirname)
+-
+- except OSError:
+- logger.error('failed to create directories', exc_info=True)
+-
+-
+-class EventHandler(object):
+- '''Event handler class. Used to store args and kwargs which are merged
+- come time to call the callback with the event args and kwargs.'''
+-
+- nextid = count().next
+-
+- def __init__(self, plugin, event, callback, args, kwargs):
+- self.id = self.nextid()
+- self.plugin = plugin
+- self.event = event
+- self.callback = callback
+- self.args = args
+- self.kwargs = kwargs
+-
+- def __repr__(self):
+- elems = ['id=%d' % self.id, 'event=%s' % self.event,
+- 'callback=%r' % self.callback]
+-
+- if self.args:
+- elems.append('args=%s' % repr(self.args))
+-
+- if self.kwargs:
+- elems.append('kwargs=%s' % repr(self.kwargs))
+-
+- elems.append('plugin=%s' % self.plugin.name)
+- return u'<handler(%s)>' % ', '.join(elems)
+-
+- def call(self, uzbl, *args, **kwargs):
+- '''Execute the handler function and merge argument lists.'''
+-
+- args = args + self.args
+- kwargs = dict(self.kwargs.items() + kwargs.items())
+- self.callback(uzbl, *args, **kwargs)
+-
+-
+-class Plugin(object):
+- '''Plugin module wrapper object.'''
+-
+- # Special functions exported from the Plugin instance to the
+- # plugin namespace.
+- special_functions = ['require', 'export', 'export_dict', 'connect',
+- 'connect_dict', 'logger', 'unquote', 'splitquoted']
+-
+- def __init__(self, parent, name, path, plugin):
+- self.parent = parent
+- self.name = name
+- self.path = path
+- self.plugin = plugin
+- self.logger = logging.getLogger('plugin.%s' % name)
+-
+- # Weakrefs to all handlers created by this plugin
+- self.handlers = set([])
+-
+- # Plugins init hook
+- init = getattr(plugin, 'init', None)
+- self.init = init if callable(init) else None
+-
+- # Plugins optional after hook
+- after = getattr(plugin, 'after', None)
+- self.after = after if callable(after) else None
+-
+- # Plugins optional cleanup hook
+- cleanup = getattr(plugin, 'cleanup', None)
+- self.cleanup = cleanup if callable(cleanup) else None
+-
+- assert init or after or cleanup, "missing hooks in plugin"
+-
+- # Export plugin's instance methods to plugin namespace
+- for attr in self.special_functions:
+- plugin.__dict__[attr] = getattr(self, attr)
+-
+- def __repr__(self):
+- return u'<plugin(%r)>' % self.plugin
+-
+- def export(self, uzbl, attr, obj, prepend=True):
+- '''Attach `obj` to `uzbl` instance. This is the preferred method
+- of sharing functionality, functions, data and objects between
+- plugins.
+-
+- If the object is callable you may wish to turn the callable object
+- in to a meta-instance-method by prepending `uzbl` to the call stack.
+- You can change this behaviour with the `prepend` argument.
+- '''
+-
+- assert attr not in uzbl.exports, "attr %r already exported by %r" %\
+- (attr, uzbl.exports[attr][0])
+-
+- prepend = True if prepend and callable(obj) else False
+- uzbl.__dict__[attr] = partial(obj, uzbl) if prepend else obj
+- uzbl.exports[attr] = (self, obj, prepend)
+- uzbl.logger.info('exported %r to %r by plugin %r, prepended %r',
+- obj, 'uzbl.%s' % attr, self.name, prepend)
+-
+- def export_dict(self, uzbl, exports):
+- for (attr, object) in exports.items():
+- self.export(uzbl, attr, object)
+-
+- def find_handler(self, event, callback, args, kwargs):
+- '''Check if a handler with the identical callback and arguments
+- exists and return it.'''
+-
+- # Remove dead refs
+- self.handlers -= set(filter(lambda ref: not ref(), self.handlers))
+-
+- # Find existing identical handler
+- for handler in [ref() for ref in self.handlers]:
+- if handler.event == event and handler.callback == callback \
+- and handler.args == args and handler.kwargs == kwargs:
+- return handler
+-
+- def connect(self, uzbl, event, callback, *args, **kwargs):
+- '''Create an event handler object which handles `event` events.
+-
+- Arguments passed to the connect function (`args` and `kwargs`) are
+- stored in the handler object and merged with the event arguments
+- come handler execution.
+-
+- All handler functions must behave like a `uzbl` instance-method (that
+- means `uzbl` is prepended to the callback call arguments).'''
+-
+- # Sanitise and check event name
+- event = event.upper().strip()
+- assert event and ' ' not in event
+-
+- assert callable(callback), 'callback must be callable'
+-
+- # Check if an identical handler already exists
+- handler = self.find_handler(event, callback, args, kwargs)
+- if not handler:
+- # Create a new handler
+- handler = EventHandler(self, event, callback, args, kwargs)
+- self.handlers.add(weakref.ref(handler))
+- self.logger.info('new %r', handler)
+-
+- uzbl.handlers[event].append(handler)
+- uzbl.logger.info('connected %r', handler)
+- return handler
+-
+- def connect_dict(self, uzbl, connects):
+- for (event, callback) in connects.items():
+- self.connect(uzbl, event, callback)
+-
+- def require(self, plugin):
+- '''Check that plugin with name `plugin` has been loaded. Use this to
+- ensure that your plugins dependencies have been met.'''
+-
+- assert plugin in self.parent.plugins, self.logger.critical(
+- 'plugin %r required by plugin %r', plugin, self.name)
+-
+- @classmethod
+- def unquote(cls, s):
+- '''Removes quotation marks around strings if any and interprets
+- \\-escape sequences using `string_escape`'''
+- if s and s[0] == s[-1] and s[0] in ['"', "'"]:
+- s = s[1:-1]
+- return s.encode('utf-8').decode('string_escape').decode('utf-8')
+-
+- _splitquoted = re.compile("( |\"(?:\\\\.|[^\"])*?\"|'(?:\\\\.|[^'])*?')")
+-
+- @classmethod
+- def splitquoted(cls, text):
+- '''Splits string on whitespace while respecting quotations'''
+- parts = cls._splitquoted.split(text)
+- return [cls.unquote(p) for p in parts if p.strip()]
+-
+-
+-class Uzbl(object):
+- def __init__(self, parent, child_socket):
+- self.opts = opts
+- self.parent = parent
+- self.child_socket = child_socket
+- self.child_buffer = []
+- self.time = time.time()
+- self.pid = None
+- self.name = None
+-
+- # Flag if the instance has raised the INSTANCE_START event.
+- self.instance_start = False
+-
+- # Use name "unknown" until name is discovered.
+- self.logger = logging.getLogger('uzbl-instance[]')
+-
+- # Track plugin event handlers and exported functions.
+- self.exports = {}
+- self.handlers = defaultdict(list)
+-
+- # Internal vars
+- self._depth = 0
+- self._buffer = ''
+-
+- def __repr__(self):
+- return '<uzbl(%s)>' % ', '.join([
+- 'pid=%s' % (self.pid if self.pid else "Unknown"),
+- 'name=%s' % ('%r' % self.name if self.name else "Unknown"),
+- 'uptime=%f' % (time.time() - self.time),
+- '%d exports' % len(self.exports.keys()),
+- '%d handlers' % sum([len(l) for l in self.handlers.values()])])
+-
+- def init_plugins(self):
+- '''Call the init and after hooks in all loaded plugins for this
+- instance.'''
+-
+- # Initialise each plugin with the current uzbl instance.
+- for plugin in self.parent.plugins.values():
+- if plugin.init:
+- self.logger.debug('calling %r plugin init hook', plugin.name)
+- plugin.init(self)
+-
+- # Allow plugins to use exported features of other plugins by calling an
+- # optional `after` function in the plugins namespace.
+- for plugin in self.parent.plugins.values():
+- if plugin.after:
+- self.logger.debug('calling %r plugin after hook', plugin.name)
+- plugin.after(self)
+-
+- def send(self, msg):
+- '''Send a command to the uzbl instance via the child socket
+- instance.'''
+-
+- msg = msg.strip()
+- assert self.child_socket, "socket inactive"
+-
+- if opts.print_events:
+- print ascii(u'%s<-- %s' % (' ' * self._depth, msg))
+-
+- self.child_buffer.append(ascii("%s\n" % msg))
+-
+- def do_send(self):
+- data = ''.join(self.child_buffer)
+- try:
+- bsent = self.child_socket.send(data)
+- except socket_error as e:
+- if e.errno in (errno.EAGAIN, errno.EINTR):
+- self.child_buffer = [data]
+- return
+- else:
+- self.logger.error('failed to send', exc_info=True)
+- return self.close()
+- else:
+- if bsent == 0:
+- self.logger.debug('write end of connection closed')
+- self.close()
+- elif bsent < len(data):
+- self.child_buffer = [data[bsent:]]
+- else:
+- del self.child_buffer[:]
+-
+- def read(self):
+- '''Read data from the child socket and pass lines to the parse_msg
+- function.'''
+-
+- try:
+- raw = unicode(self.child_socket.recv(8192), 'utf-8', 'ignore')
+- if not raw:
+- self.logger.debug('read null byte')
+- return self.close()
+-
+- except:
+- self.logger.error('failed to read', exc_info=True)
+- return self.close()
+-
+- lines = (self._buffer + raw).split('\n')
+- self._buffer = lines.pop()
+-
+- for line in filter(None, map(unicode.strip, lines)):
+- try:
+- self.parse_msg(line.strip())
+-
+- except:
+- self.logger.error(get_exc())
+- self.logger.error('erroneous event: %r' % line)
+-
+- def parse_msg(self, line):
+- '''Parse an incoming message from a uzbl instance. Event strings
+- will be parsed into `self.event(event, args)`.'''
+-
+- # Split by spaces (and fill missing with nulls)
+- elems = (line.split(' ', 3) + [''] * 3)[:4]
+-
+- # Ignore non-event messages.
+- if elems[0] != 'EVENT':
+- logger.info('non-event message: %r', line)
+- if opts.print_events:
+- print '--- %s' % ascii(line)
+- return
+-
+- # Check event string elements
+- (name, event, args) = elems[1:]
+- assert name and event, 'event string missing elements'
+- if not self.name:
+- self.name = name
+- self.logger = logging.getLogger('uzbl-instance%s' % name)
+- self.logger.info('found instance name %r', name)
+-
+- assert self.name == name, 'instance name mismatch'
+-
+- # Handle the event with the event handlers through the event method
+- self.event(event, args)
+-
+- def event(self, event, *args, **kargs):
+- '''Raise an event.'''
+-
+- event = event.upper()
+-
+- if not opts.daemon_mode and opts.print_events:
+- elems = [event]
+- if args:
+- elems.append(unicode(args))
+- if kargs:
+- elems.append(unicode(kargs))
+- print ascii(u'%s--> %s' % (' ' * self._depth, ' '.join(elems)))
+-
+- if event == "INSTANCE_START" and args:
+- assert not self.instance_start, 'instance already started'
+-
+- self.pid = int(args[0])
+- self.logger.info('found instance pid %r', self.pid)
+-
+- self.init_plugins()
+-
+- elif event == "INSTANCE_EXIT":
+- self.logger.info('uzbl instance exit')
+- self.close()
+-
+- if event not in self.handlers:
+- return
+-
+- for handler in self.handlers[event]:
+- self._depth += 1
+- try:
+- handler.call(self, *args, **kargs)
+-
+- except:
+- self.logger.error('error in handler', exc_info=True)
+-
+- self._depth -= 1
+-
+- def close_connection(self, child_socket):
+- '''Close child socket and delete the uzbl instance created for that
+- child socket connection.'''
+-
+- def close(self):
+- '''Close the client socket and call the plugin cleanup hooks.'''
+-
+- self.logger.debug('called close method')
+-
+- # Remove self from parent uzbls dict.
+- if self.child_socket in self.parent.uzbls:
+- self.logger.debug('removing self from uzbls list')
+- del self.parent.uzbls[self.child_socket]
+-
+- try:
+- if self.child_socket:
+- self.logger.debug('closing child socket')
+- self.child_socket.close()
+-
+- except:
+- self.logger.error('failed to close socket', exc_info=True)
+-
+- finally:
+- self.child_socket = None
+-
+- # Call plugins cleanup hooks.
+- for plugin in self.parent.plugins.values():
+- if plugin.cleanup:
+- self.logger.debug('calling %r plugin cleanup hook',
+- plugin.name)
+- plugin.cleanup(self)
+-
+- logger.info('removed %r', self)
+-
+-
+-class UzblEventDaemon(object):
+- def __init__(self):
+- self.opts = opts
+- self.server_socket = None
+- self._quit = False
+-
+- # Hold uzbl instances
+- # {child socket: Uzbl instance, ..}
+- self.uzbls = {}
+-
+- # Hold plugins
+- # {plugin name: Plugin instance, ..}
+- self.plugins = {}
+-
+- # Register that the event daemon server has started by creating the
+- # pid file.
+- make_pid_file(opts.pid_file)
+-
+- # Register a function to clean up the socket and pid file on exit.
+- atexit.register(self.quit)
+-
+- # Add signal handlers.
+- for sigint in [SIGTERM, SIGINT]:
+- signal(sigint, self.quit)
+-
+- # Load plugins into self.plugins
+- self.load_plugins(opts.plugins)
+-
+- def load_plugins(self, plugins):
+- '''Load event manager plugins.'''
+-
+- for path in plugins:
+- logger.debug('loading plugin %r', path)
+- (dir, file) = os.path.split(path)
+- name = file[:-3] if file.lower().endswith('.py') else file
+-
+- info = imp.find_module(name, [dir])
+- module = imp.load_module(name, *info)
+-
+- # Check if the plugin has a callable hook.
+- hooks = filter(callable, [getattr(module, attr, None) \
+- for attr in ['init', 'after', 'cleanup']])
+- assert hooks, "no hooks in plugin %r" % module
+-
+- logger.debug('creating plugin instance for %r plugin', name)
+- plugin = Plugin(self, name, path, module)
+- self.plugins[name] = plugin
+- logger.info('new %r', plugin)
+-
+- def create_server_socket(self):
+- '''Create the event manager daemon socket for uzbl instance duplex
+- communication.'''
+-
+- # Close old socket.
+- self.close_server_socket()
+-
+- sock = socket(AF_UNIX, SOCK_STREAM)
+- sock.bind(opts.server_socket)
+- sock.listen(5)
+-
+- self.server_socket = sock
+- logger.debug('bound server socket to %r', opts.server_socket)
+-
+- def run(self):
+- '''Main event daemon loop.'''
+-
+- logger.debug('entering main loop')
+-
+- # Create and listen on the server socket
+- self.create_server_socket()
+-
+- if opts.daemon_mode:
+- # Daemonize the process
+- daemonize()
+-
+- # Update the pid file
+- make_pid_file(opts.pid_file)
+-
+- try:
+- # Accept incoming connections and listen for incoming data
+- self.listen()
+-
+- except:
+- if not self._quit:
+- logger.critical('failed to listen', exc_info=True)
+-
+- # Clean up and exit
+- self.quit()
+-
+- logger.debug('exiting main loop')
+-
+- def listen(self):
+- '''Accept incoming connections and constantly poll instance sockets
+- for incoming data.'''
+-
+- logger.info('listening on %r', opts.server_socket)
+-
+- # Count accepted connections
+- connections = 0
+-
+- while (self.uzbls or not connections) or (not opts.auto_close):
+- socks = [self.server_socket] + self.uzbls.keys()
+- wsocks = [k for k, v in self.uzbls.items() if v.child_buffer]
+- reads, writes, errors = select(socks, wsocks, socks, 1)
+-
+- if self.server_socket in reads:
+- reads.remove(self.server_socket)
+-
+- # Accept connection and create uzbl instance.
+- child_socket = self.server_socket.accept()[0]
+- child_socket.setblocking(False)
+- self.uzbls[child_socket] = Uzbl(self, child_socket)
+- connections += 1
+-
+- for uzbl in [self.uzbls[s] for s in writes if s in self.uzbls ]:
+- uzbl.do_send()
+-
+- for uzbl in [self.uzbls[s] for s in reads if s in self.uzbls]:
+- uzbl.read()
+-
+- for uzbl in [self.uzbls[s] for s in errors if s in self.uzbls]:
+- uzbl.logger.error('socket read error')
+- uzbl.close()
+-
+- logger.info('auto closing')
+-
+- def close_server_socket(self):
+- '''Close and delete the server socket.'''
+-
+- try:
+- if self.server_socket:
+- logger.debug('closing server socket')
+- self.server_socket.close()
+- self.server_socket = None
+-
+- if os.path.exists(opts.server_socket):
+- logger.info('unlinking %r', opts.server_socket)
+- os.unlink(opts.server_socket)
+-
+- except:
+- logger.error('failed to close server socket', exc_info=True)
+-
+- def quit(self, sigint=None, *args):
+- '''Close all instance socket objects, server socket and delete the
+- pid file.'''
+-
+- if sigint == SIGTERM:
+- logger.critical('caught SIGTERM, exiting')
+-
+- elif sigint == SIGINT:
+- logger.critical('caught SIGINT, exiting')
+-
+- elif not self._quit:
+- logger.debug('shutting down event manager')
+-
+- self.close_server_socket()
+-
+- for uzbl in self.uzbls.values():
+- uzbl.close()
+-
+- del_pid_file(opts.pid_file)
+-
+- if not self._quit:
+- logger.info('event manager shut down')
+- self._quit = True
+-
+-
+-def make_pid_file(pid_file):
+- '''Creates a pid file at `pid_file`, fails silently.'''
+-
+- try:
+- logger.debug('creating pid file %r', pid_file)
+- make_dirs(pid_file)
+- pid = os.getpid()
+- fileobj = open(pid_file, 'w')
+- fileobj.write('%d' % pid)
+- fileobj.close()
+- logger.info('created pid file %r with pid %d', pid_file, pid)
+-
+- except:
+- logger.error('failed to create pid file', exc_info=True)
+-
+-
+-def del_pid_file(pid_file):
+- '''Deletes a pid file at `pid_file`, fails silently.'''
+-
+- if os.path.isfile(pid_file):
+- try:
+- logger.debug('deleting pid file %r', pid_file)
+- os.remove(pid_file)
+- logger.info('deleted pid file %r', pid_file)
+-
+- except:
+- logger.error('failed to delete pid file', exc_info=True)
+-
+-
+-def get_pid(pid_file):
+- '''Reads a pid from pid file `pid_file`, fails None.'''
+-
+- try:
+- logger.debug('reading pid file %r', pid_file)
+- fileobj = open(pid_file, 'r')
+- pid = int(fileobj.read())
+- fileobj.close()
+- logger.info('read pid %d from pid file %r', pid, pid_file)
+- return pid
+-
+- except (IOError, ValueError):
+- logger.error('failed to read pid', exc_info=True)
+- return None
+-
+-
+-def pid_running(pid):
+- '''Checks if a process with a pid `pid` is running.'''
+-
+- try:
+- os.kill(pid, 0)
+- except OSError:
+- return False
+- else:
+- return True
+-
+-
+-def term_process(pid):
+- '''Asks nicely then forces process with pid `pid` to exit.'''
+-
+- try:
+- logger.info('sending SIGTERM to process with pid %r', pid)
+- os.kill(pid, SIGTERM)
+-
+- except OSError:
+- logger.error(get_exc())
+-
+- logger.debug('waiting for process with pid %r to exit', pid)
+- start = time.time()
+- while True:
+- if not pid_running(pid):
+- logger.debug('process with pid %d exit', pid)
+- return True
+-
+- if (time.time() - start) > 5:
+- logger.warning('process with pid %d failed to exit', pid)
+- logger.info('sending SIGKILL to process with pid %d', pid)
+- try:
+- os.kill(pid, SIGKILL)
+- except:
+- logger.critical('failed to kill %d', pid, exc_info=True)
+- raise
+-
+- if (time.time() - start) > 10:
+- logger.critical('unable to kill process with pid %d', pid)
+- raise OSError
+-
+- time.sleep(0.25)
+-
+-
+-def stop_action():
+- '''Stop the event manager daemon.'''
+-
+- pid_file = opts.pid_file
+- if not os.path.isfile(pid_file):
+- logger.error('could not find running event manager with pid file %r',
+- pid_file)
+- return
+-
+- pid = get_pid(pid_file)
+- if not pid_running(pid):
+- logger.debug('no process with pid %r', pid)
+- del_pid_file(pid_file)
+- return
+-
+- logger.debug('terminating process with pid %r', pid)
+- term_process(pid)
+- del_pid_file(pid_file)
+- logger.info('stopped event manager process with pid %d', pid)
+-
+-
+-def start_action():
+- '''Start the event manager daemon.'''
+-
+- pid_file = opts.pid_file
+- if os.path.isfile(pid_file):
+- pid = get_pid(pid_file)
+- if pid_running(pid):
+- logger.error('event manager already started with pid %d', pid)
+- return
+-
+- logger.info('no process with pid %d', pid)
+- del_pid_file(pid_file)
+-
+- UzblEventDaemon().run()
+-
+-
+-def restart_action():
+- '''Restart the event manager daemon.'''
+-
+- stop_action()
+- start_action()
+-
+-
+-def list_action():
+- '''List all the plugins that would be loaded in the current search
+- dirs.'''
+-
+- names = {}
+- for plugin in opts.plugins:
+- (head, tail) = os.path.split(plugin)
+- if tail not in names:
+- names[tail] = plugin
+-
+- for plugin in sorted(names.values()):
+- print plugin
+-
+-
+-def make_parser():
+- parser = OptionParser('usage: %prog [options] {start|stop|restart|list}')
+- add = parser.add_option
+-
+- add('-v', '--verbose',
+- dest='verbose', default=2, action='count',
+- help='increase verbosity')
+-
+- add('-d', '--plugin-dir',
+- dest='plugin_dirs', action='append', metavar="DIR", default=[],
+- help='add extra plugin search dir, same as `-l "DIR/*.py"`')
+-
+- add('-l', '--load-plugin',
+- dest='load_plugins', action='append', metavar="PLUGIN", default=[],
+- help='load plugin, loads before plugins in search dirs')
+-
+- socket_location = os.path.join(CACHE_DIR, 'event_daemon')
+-
+- add('-s', '--server-socket',
+- dest='server_socket', metavar="SOCKET", default=socket_location,
+- help='server AF_UNIX socket location')
+-
+- add('-p', '--pid-file',
+- metavar="FILE", dest='pid_file',
+- help='pid file location, defaults to server socket + .pid')
+-
+- add('-n', '--no-daemon',
+- dest='daemon_mode', action='store_false', default=True,
+- help='do not daemonize the process')
+-
+- add('-a', '--auto-close',
+- dest='auto_close', action='store_true', default=False,
+- help='auto close after all instances disconnect')
+-
+- add('-i', '--no-default-dirs',
+- dest='default_dirs', action='store_false', default=True,
+- help='ignore the default plugin search dirs')
+-
+- add('-o', '--log-file',
+- dest='log_file', metavar='FILE',
+- help='write logging output to a file, defaults to server socket +'
+- ' .log')
+-
+- add('-q', '--quiet-events',
+- dest='print_events', action="store_false", default=True,
+- help="silence the printing of events to stdout")
+-
+- return parser
+-
+-
+-def init_logger():
+- log_level = logging.CRITICAL - opts.verbose * 10
+- logger = logging.getLogger()
+- logger.setLevel(max(log_level, 10))
+-
+- # Console
+- handler = logging.StreamHandler()
+- handler.setLevel(max(log_level + 10, 10))
+- handler.setFormatter(logging.Formatter(
+- '%(name)s: %(levelname)s: %(message)s'))
+- logger.addHandler(handler)
+-
+- # Logfile
+- handler = logging.FileHandler(opts.log_file, 'w', 'utf-8', 1)
+- handler.setLevel(max(log_level, 10))
+- handler.setFormatter(logging.Formatter(
+- '[%(created)f] %(name)s: %(levelname)s: %(message)s'))
+- logger.addHandler(handler)
+-
+-
+-def main():
+- global opts
+-
+- parser = make_parser()
+-
+- (opts, args) = parser.parse_args()
+-
+- opts.server_socket = expandpath(opts.server_socket)
+-
+- # Set default pid file location
+- if not opts.pid_file:
+- opts.pid_file = "%s.pid" % opts.server_socket
+-
+- else:
+- opts.pid_file = expandpath(opts.pid_file)
+-
+- # Set default log file location
+- if not opts.log_file:
+- opts.log_file = "%s.log" % opts.server_socket
+-
+- else:
+- opts.log_file = expandpath(opts.log_file)
+-
+- # Logging setup
+- init_logger()
+- logger.info('logging to %r', opts.log_file)
+-
+- plugins = {}
+-
+- # Load all `opts.load_plugins` into the plugins list
+- for path in opts.load_plugins:
+- path = expandpath(path)
+- matches = glob(path)
+- if not matches:
+- parser.error('cannot find plugin(s): %r' % path)
+-
+- for plugin in matches:
+- (head, tail) = os.path.split(plugin)
+- if tail not in plugins:
+- logger.debug('found plugin: %r', plugin)
+- plugins[tail] = plugin
+-
+- else:
+- logger.debug('ignoring plugin: %r', plugin)
+-
+- # Add default plugin locations
+- if opts.default_dirs:
+- logger.debug('adding default plugin dirs to plugin dirs list')
+- opts.plugin_dirs += [os.path.join(DATA_DIR, 'plugins/'),
+- os.path.join(PREFIX, 'share/uzbl/examples/data/plugins/')]
+-
+- else:
+- logger.debug('ignoring default plugin dirs')
+-
+- # Load all plugins in `opts.plugin_dirs` into the plugins list
+- for dir in opts.plugin_dirs:
+- dir = expandpath(dir)
+- logger.debug('searching plugin dir: %r', dir)
+- for plugin in glob(os.path.join(dir, '*.py')):
+- (head, tail) = os.path.split(plugin)
+- if tail not in plugins:
+- logger.debug('found plugin: %r', plugin)
+- plugins[tail] = plugin
+-
+- else:
+- logger.debug('ignoring plugin: %r', plugin)
+-
+- plugins = plugins.values()
+-
+- # Check all the paths in the plugins list are files
+- for plugin in plugins:
+- if not os.path.isfile(plugin):
+- parser.error('plugin not a file: %r' % plugin)
+-
+- if opts.auto_close:
+- logger.debug('will auto close')
+- else:
+- logger.debug('will not auto close')
+-
+- if opts.daemon_mode:
+- logger.debug('will daemonize')
+- else:
+- logger.debug('will not daemonize')
+-
+- opts.plugins = plugins
+-
+- # init like {start|stop|..} daemon actions
+- daemon_actions = {'start': start_action, 'stop': stop_action,
+- 'restart': restart_action, 'list': list_action}
+-
+- if len(args) == 1:
+- action = args[0]
+- if action not in daemon_actions:
+- parser.error('invalid action: %r' % action)
+-
+- elif not args:
+- action = 'start'
+- logger.warning('no daemon action given, assuming %r', action)
+-
+- else:
+- parser.error('invalid action argument: %r' % args)
+-
+- logger.info('daemon action %r', action)
+- # Do action
+- daemon_actions[action]()
+-
+- logger.debug('process CPU time: %f', time.clock())
+-
+-
+-if __name__ == "__main__":
+- main()
+-
+-
+-# vi: set et ts=4:
++#!/usr/bin/python3
++from uzbl import event_manager
++event_manager.main()
+diff --git a/bin/uzbl-tabbed b/bin/uzbl-tabbed
+index b78a54a..12fa249 100755
+--- a/bin/uzbl-tabbed
++++ b/bin/uzbl-tabbed
+@@ -47,6 +47,10 @@
+ #
+ # Simon Lipp (sloonz)
+ # Various
++#
++# Hakan Jerning
++# Wrote autosave_session patch to have a saved session even if
++# uzbl-tabbed is closed unexpectedly.
+
+
+ # Dependencies:
+@@ -85,6 +89,7 @@
+ # save_session = 1
+ # json_session = 0
+ # session_file = $HOME/.local/share/uzbl/session
++# autosave_session = 0
+ #
+ # Inherited uzbl options:
+ # icon_path = $HOME/.local/share/uzbl/uzbl.png
+@@ -209,6 +214,7 @@ config = {
+ 'save_session': True, # Save session in file when quit
+ 'saved_sessions_dir': os.path.join(DATA_DIR, 'sessions/'),
+ 'session_file': os.path.join(DATA_DIR, 'session'),
++ 'autosave_session': False, # Save session for every tab change
+
+ # Inherited uzbl options
+ 'icon_path': os.path.join(DATA_DIR, 'uzbl.png'),
+@@ -232,6 +238,11 @@ config = {
+ 'selected_https': 'foreground = "#fff"',
+ 'selected_https_text': 'foreground = "gold"',
+
++ #Explicit config file. Unlike the other configs, this one cannot be inherited
++ #from the uzbl config file, as stated above. I've only put it here because
++ #load_session() is already called in UzblTabbed.__init__.
++ 'explicit_config_file': None,
++
+ } # End of config dict.
+
+ UZBL_TABBED_VARS = config.keys()
+@@ -410,7 +421,7 @@ class GlobalEventDispatcher(EventDispatcher):
+ def new_tab(self, uri = ''):
+ self.uzbl_tabbed.new_tab(uri)
+
+- def new_tab_bg(self, uri = ''):
++ def new_bg_tab(self, uri = ''):
+ self.uzbl_tabbed.new_tab(uri, switch = False)
+
+ def new_tab_next(self, uri = ''):
+@@ -434,6 +445,15 @@ class GlobalEventDispatcher(EventDispatcher):
+ def last_tab(self):
+ self.uzbl_tabbed.goto_tab(-1)
+
++ def move_current_tab(self, index=0):
++ self.uzbl_tabbed.move_current_tab(absolute=int(index))
++
++ def move_current_tab_left(self):
++ self.uzbl_tabbed.move_current_tab(relative=-1)
++
++ def move_current_tab_right(self):
++ self.uzbl_tabbed.move_current_tab(relative=1)
++
+ def preset_tabs(self, *args):
+ self.uzbl_tabbed.run_preset_command(*args)
+
+@@ -889,6 +909,9 @@ class UzblTabbed:
+ if(uri):
+ cmd = cmd + ['--uri', str(uri)]
+
++ if config['explicit_config_file'] is not None:
++ cmd = cmd + ['-c', config['explicit_config_file']]
++
+ gobject.spawn_async(cmd, flags=gobject.SPAWN_SEARCH_PATH)
+
+ uzbl = UzblInstance(self, name, uri, title, switch)
+@@ -968,6 +991,18 @@ class UzblTabbed:
+ while tabn < 0: tabn += ntabs
+ self.goto_tab(tabn)
+
++ def move_tab(self, tab, index):
++ '''Move tab to position.'''
++ self.notebook.reorder_child(tab, index)
++ self.update_tablist()
++
++ def move_current_tab(self, absolute=None, relative=None):
++ '''Move current tab to position.'''
++ current = self.notebook.get_current_page()
++ index = absolute if absolute is not None else current + relative \
++ if current + relative < len(self.notebook) else 0
++ tab = self.notebook.get_nth_page(current)
++ self.move_tab(tab, index)
+
+ def close_tab(self, tabn=None):
+ '''Closes current tab. Supports negative indexing.'''
+@@ -1030,6 +1065,11 @@ class UzblTabbed:
+ tab = self.notebook.get_nth_page(index)
+ self.notebook.set_focus_child(tab)
+ self.update_tablist(index)
++
++ if config['save_session'] and config['autosave_session']:
++ if len(list(self.notebook)) > 1:
++ self.save_session()
++
+ return True
+
+
+@@ -1038,6 +1078,7 @@ class UzblTabbed:
+
+ for tab in self.notebook:
+ self.tabs[tab].title_changed(True)
++ self.update_tablist()
+ return True
+
+
+@@ -1261,6 +1302,8 @@ if __name__ == "__main__":
+ help="directory to create socket")
+ parser.add_option('-f', '--fifodir', dest='fifodir',
+ help="directory to create fifo")
++ parser.add_option('--config-file', dest='config_file',
++ help="configuration file for all uzbl-browser instances")
+
+ # Parse command line options
+ (options, uris) = parser.parse_args()
+@@ -1275,6 +1318,15 @@ if __name__ == "__main__":
+ import pprint
+ sys.stderr.write("%s\n" % pprint.pformat(config))
+
++ if options.config_file is not None:
++ if not os.path.exists(options.config_file):
++ errorstr = "Explicit config file {} does not exist" % (
++ options.config_file)
++ error(errorstr)
++ sys.exit(-1)
++
++ config['explicit_config_file'] = options.config_file
++
+ uzbl = UzblTabbed()
+
+ if options.socketdir:
+diff --git a/examples/config/config b/examples/config/config
+index 11f1d82..d607cb4 100644
+--- a/examples/config/config
++++ b/examples/config/config
+@@ -8,6 +8,7 @@ set prefix = @(echo $PREFIX)@
+ set data_home = @(echo $XDG_DATA_HOME)@
+ set cache_home = @(echo $XDG_CACHE_HOME)@
+ set config_home = @(echo $XDG_CONFIG_HOME)@
++set local_storage_path = @data_home/uzbl/databases/
+
+ # Interface paths.
+ set fifo_dir = /tmp
+@@ -70,7 +71,6 @@ set download_handler = sync_spawn @scripts_dir/download.sh
+ @on_event LOAD_COMMIT @set_status <span foreground="green">recv</span>
+
+ # add some javascript to the page for other 'js' and 'script' commands to access later.
+-@on_event LOAD_COMMIT js uzbl = {};
+ @on_event LOAD_COMMIT script @scripts_dir/formfiller.js
+ @on_event LOAD_COMMIT script @scripts_dir/follow.js
+
+@@ -86,6 +86,8 @@ set download_handler = sync_spawn @scripts_dir/download.sh
+ # Switch to command mode if anything else is clicked
+ @on_event ROOT_ACTIVE @set_mode command
+
++@on_event AUTHENTICATE spawn @scripts_dir/auth.py "%1" "%2" "%3"
++
+ # Example CONFIG_CHANGED event handler
+ #@on_event CONFIG_CHANGED print Config changed: %1 = %2
+
+@@ -97,6 +99,10 @@ set download_handler = sync_spawn @scripts_dir/download.sh
+ # Custom CSS can be defined here, including link follower hint styles
+ set stylesheet_uri = file://@config_home/uzbl/style.css
+
++# If WebKits builtin authentication dialog should be used, if enabling remember
++# to disable external authentication handlers
++set enable_builtin_auth = 0
++
+ set show_status = 1
+ set status_top = 0
+ set status_background = #303030
+@@ -138,6 +144,8 @@ set useragent = Uzbl (Webkit @{WEBKIT_MAJOR}.@{WEBKIT_MINOR}) (@(+uname
+
+ # === Configure cookie blacklist ========================================================
+
++set cookie_policy = 0
++
+ # Accept 'session cookies' from uzbl.org (when you have a whitelist all other cookies are dropped)
+ #request WHITELIST_COOKIE domain 'uzbl.org$' expires '^$'
+
+@@ -404,6 +412,9 @@ set formfiller = spawn @scripts_dir/formfiller.sh
+ @cbind gt = event NEXT_TAB
+ @cbind gT = event PREV_TAB
+ @cbind gi<index:>_ = event GOTO_TAB %s
++@cbind <Ctrl><Left> = event MOVE_CURRENT_TAB_LEFT
++@cbind <Ctrl><Right> = event MOVE_CURRENT_TAB_RIGHT
++@cbind gm<index:>_ = event MOVE_CURRENT_TAB %s
+
+ # Preset loading
+ set preset = event PRESET_TABS
+diff --git a/examples/data/plugins/bind.py b/examples/data/plugins/bind.py
+deleted file mode 100644
+index fc8b392..0000000
+--- a/examples/data/plugins/bind.py
++++ /dev/null
+@@ -1,462 +0,0 @@
+-'''Plugin provides support for binds in uzbl.
+-
+-For example:
+- event BIND ZZ = exit -> bind('ZZ', 'exit')
+- event BIND o _ = uri %s -> bind('o _', 'uri %s')
+- event BIND fl* = sh 'echo %s' -> bind('fl*', "sh 'echo %s'")
+-
+-And it is also possible to execute a function on activation:
+- bind('DD', myhandler)
+-'''
+-
+-import sys
+-import re
+-
+-# Commonly used regular expressions.
+-MOD_START = re.compile('^<([A-Z][A-Za-z0-9-_]*)>').match
+-# Matches <x:y>, <'x':y>, <:'y'>, <x!y>, <'x'!y>, ...
+-PROMPTS = '<(\"[^\"]*\"|\'[^\']*\'|[^:!>]*)(:|!)(\"[^\"]*\"|\'[^\']*\'|[^>]*)>'
+-FIND_PROMPTS = re.compile(PROMPTS).split
+-VALID_MODE = re.compile('^(-|)[A-Za-z0-9][A-Za-z0-9_]*$').match
+-
+-# For accessing a bind glob stack.
+-ON_EXEC, HAS_ARGS, MOD_CMD, GLOB, MORE = range(5)
+-
+-
+-# Custom errors.
+-class ArgumentError(Exception): pass
+-
+-
+-class Bindlet(object):
+- '''Per-instance bind status/state tracker.'''
+-
+- def __init__(self, uzbl):
+- self.binds = {'global': {}}
+- self.uzbl = uzbl
+- self.depth = 0
+- self.args = []
+- self.last_mode = None
+- self.after_cmds = None
+- self.stack_binds = []
+-
+- # A subset of the global mode binds containing non-stack and modkey
+- # activiated binds for use in the stack mode.
+- self.globals = []
+-
+-
+- def __getitem__(self, key):
+- return self.get_binds(key)
+-
+-
+- def reset(self):
+- '''Reset the tracker state and return to last mode.'''
+-
+- self.depth = 0
+- self.args = []
+- self.after_cmds = None
+- self.stack_binds = []
+-
+- if self.last_mode:
+- mode, self.last_mode = self.last_mode, None
+- self.uzbl.config['mode'] = mode
+-
+- del self.uzbl.config['keycmd_prompt']
+-
+-
+- def stack(self, bind, args, depth):
+- '''Enter or add new bind in the next stack level.'''
+-
+- if self.depth != depth:
+- if bind not in self.stack_binds:
+- self.stack_binds.append(bind)
+-
+- return
+-
+- mode = self.uzbl.config.get('mode', None)
+- if mode != 'stack':
+- self.last_mode = mode
+- self.uzbl.config['mode'] = 'stack'
+-
+- self.stack_binds = [bind,]
+- self.args += args
+- self.depth += 1
+- self.after_cmds = bind.prompts[depth]
+-
+-
+- def after(self):
+- '''If a stack was triggered then set the prompt and default value.'''
+-
+- if self.after_cmds is None:
+- return
+-
+- (prompt, is_cmd, set), self.after_cmds = self.after_cmds, None
+-
+- self.uzbl.clear_keycmd()
+- if prompt:
+- self.uzbl.config['keycmd_prompt'] = prompt
+-
+- if set and is_cmd:
+- self.uzbl.send(set)
+-
+- elif set and not is_cmd:
+- self.uzbl.send('event SET_KEYCMD %s' % set)
+-
+-
+- def get_binds(self, mode=None):
+- '''Return the mode binds + globals. If we are stacked then return
+- the filtered stack list and modkey & non-stack globals.'''
+-
+- if mode is None:
+- mode = self.uzbl.config.get('mode', None)
+-
+- if not mode:
+- mode = 'global'
+-
+- if self.depth:
+- return self.stack_binds + self.globals
+-
+- globals = self.binds['global']
+- if mode not in self.binds or mode == 'global':
+- return filter(None, globals.values())
+-
+- binds = dict(globals.items() + self.binds[mode].items())
+- return filter(None, binds.values())
+-
+-
+- def add_bind(self, mode, glob, bind=None):
+- '''Insert (or override) a bind into the mode bind dict.'''
+-
+- if mode not in self.binds:
+- self.binds[mode] = {glob: bind}
+- return
+-
+- binds = self.binds[mode]
+- binds[glob] = bind
+-
+- if mode == 'global':
+- # Regen the global-globals list.
+- self.globals = []
+- for bind in binds.values():
+- if bind is not None and bind.is_global:
+- self.globals.append(bind)
+-
+-
+-def ismodbind(glob):
+- '''Return True if the glob specifies a modbind.'''
+-
+- return bool(MOD_START(glob))
+-
+-
+-def split_glob(glob):
+- '''Take a string of the form "<Mod1><Mod2>cmd _" and return a list of the
+- modkeys in the glob and the command.'''
+-
+- mods = set()
+- while True:
+- match = MOD_START(glob)
+- if not match:
+- break
+-
+- end = match.span()[1]
+- mods.add(glob[:end])
+- glob = glob[end:]
+-
+- return (mods, glob)
+-
+-
+-class Bind(object):
+-
+- # Class attribute to hold the number of Bind classes created.
+- counter = [0,]
+-
+- def __init__(self, glob, handler, *args, **kargs):
+- self.is_callable = callable(handler)
+- self._repr_cache = None
+-
+- if not glob:
+- raise ArgumentError('glob cannot be blank')
+-
+- if self.is_callable:
+- self.function = handler
+- self.args = args
+- self.kargs = kargs
+-
+- elif kargs:
+- raise ArgumentError('cannot supply kargs for uzbl commands')
+-
+- elif hasattr(handler, '__iter__'):
+- self.commands = handler
+-
+- else:
+- self.commands = [handler,] + list(args)
+-
+- self.glob = glob
+-
+- # Assign unique id.
+- self.counter[0] += 1
+- self.bid = self.counter[0]
+-
+- self.split = split = FIND_PROMPTS(glob)
+- self.prompts = []
+- for (prompt, cmd, set) in zip(split[1::4], split[2::4], split[3::4]):
+- prompt, set = map(unquote, [prompt, set])
+- cmd = True if cmd == '!' else False
+- if prompt and prompt[-1] != ":":
+- prompt = "%s:" % prompt
+-
+- self.prompts.append((prompt, cmd, set))
+-
+- # Check that there is nothing like: fl*<int:>*
+- for glob in split[:-1:4]:
+- if glob.endswith('*'):
+- msg = "token '*' not at the end of a prompt bind: %r" % split
+- raise SyntaxError(msg)
+-
+- # Check that there is nothing like: fl<prompt1:><prompt2:>_
+- for glob in split[4::4]:
+- if not glob:
+- msg = 'found null segment after first prompt: %r' % split
+- raise SyntaxError(msg)
+-
+- stack = []
+- for (index, glob) in enumerate(reversed(split[::4])):
+- # Is the binding a MODCMD or KEYCMD:
+- mod_cmd = ismodbind(glob)
+-
+- # Do we execute on UPDATES or EXEC events?
+- on_exec = True if glob[-1] in ['!', '_'] else False
+-
+- # Does the command take arguments?
+- has_args = True if glob[-1] in ['*', '_'] else False
+-
+- glob = glob[:-1] if has_args or on_exec else glob
+- mods, glob = split_glob(glob)
+- stack.append((on_exec, has_args, mods, glob, index))
+-
+- self.stack = list(reversed(stack))
+- self.is_global = (len(self.stack) == 1 and self.stack[0][MOD_CMD])
+-
+-
+- def __getitem__(self, depth):
+- '''Get bind info at a depth.'''
+-
+- if self.is_global:
+- return self.stack[0]
+-
+- return self.stack[depth]
+-
+-
+- def __repr__(self):
+- if self._repr_cache:
+- return self._repr_cache
+-
+- args = ['glob=%r' % self.glob, 'bid=%d' % self.bid]
+-
+- if self.is_callable:
+- args.append('function=%r' % self.function)
+- if self.args:
+- args.append('args=%r' % self.args)
+-
+- if self.kargs:
+- args.append('kargs=%r' % self.kargs)
+-
+- else:
+- cmdlen = len(self.commands)
+- cmds = self.commands[0] if cmdlen == 1 else self.commands
+- args.append('command%s=%r' % ('s' if cmdlen-1 else '', cmds))
+-
+- self._repr_cache = '<Bind(%s)>' % ', '.join(args)
+- return self._repr_cache
+-
+-
+-def exec_bind(uzbl, bind, *args, **kargs):
+- '''Execute bind objects.'''
+-
+- uzbl.event("EXEC_BIND", bind, args, kargs)
+-
+- if bind.is_callable:
+- args += bind.args
+- kargs = dict(bind.kargs.items()+kargs.items())
+- bind.function(uzbl, *args, **kargs)
+- return
+-
+- if kargs:
+- raise ArgumentError('cannot supply kargs for uzbl commands')
+-
+- commands = []
+- cmd_expand = uzbl.cmd_expand
+- for cmd in bind.commands:
+- cmd = cmd_expand(cmd, args)
+- uzbl.send(cmd)
+-
+-
+-def mode_bind(uzbl, modes, glob, handler=None, *args, **kargs):
+- '''Add a mode bind.'''
+-
+- bindlet = uzbl.bindlet
+-
+- if not hasattr(modes, '__iter__'):
+- modes = unicode(modes).split(',')
+-
+- # Sort and filter binds.
+- modes = filter(None, map(unicode.strip, modes))
+-
+- if callable(handler) or (handler is not None and handler.strip()):
+- bind = Bind(glob, handler, *args, **kargs)
+-
+- else:
+- bind = None
+-
+- for mode in modes:
+- if not VALID_MODE(mode):
+- raise NameError('invalid mode name: %r' % mode)
+-
+- for mode in modes:
+- if mode[0] == '-':
+- mode, bind = mode[1:], None
+-
+- bindlet.add_bind(mode, glob, bind)
+- uzbl.event('ADDED_MODE_BIND', mode, glob, bind)
+-
+-
+-def bind(uzbl, glob, handler, *args, **kargs):
+- '''Legacy bind function.'''
+-
+- mode_bind(uzbl, 'global', glob, handler, *args, **kargs)
+-
+-
+-def parse_mode_bind(uzbl, args):
+- '''Parser for the MODE_BIND event.
+-
+- Example events:
+- MODE_BIND <mode> <bind> = <command>
+- MODE_BIND command o<location:>_ = uri %s
+- MODE_BIND insert,command <BackSpace> = ...
+- MODE_BIND global ... = ...
+- MODE_BIND global,-insert ... = ...
+- '''
+-
+- if not args:
+- raise ArgumentError('missing bind arguments')
+-
+- split = map(unicode.strip, args.split(' ', 1))
+- if len(split) != 2:
+- raise ArgumentError('missing mode or bind section: %r' % args)
+-
+- modes, args = split[0].split(','), split[1]
+- split = map(unicode.strip, args.split('=', 1))
+- if len(split) != 2:
+- raise ArgumentError('missing delimiter in bind section: %r' % args)
+-
+- glob, command = split
+- mode_bind(uzbl, modes, glob, command)
+-
+-
+-def parse_bind(uzbl, args):
+- '''Legacy parsing of the BIND event and conversion to the new format.
+-
+- Example events:
+- request BIND <bind> = <command>
+- request BIND o<location:>_ = uri %s
+- request BIND <BackSpace> = ...
+- request BIND ... = ...
+- '''
+-
+- parse_mode_bind(uzbl, "global %s" % args)
+-
+-
+-def mode_changed(uzbl, mode):
+- '''Clear the stack on all non-stack mode changes.'''
+-
+- if mode != 'stack':
+- uzbl.bindlet.reset()
+-
+-
+-def match_and_exec(uzbl, bind, depth, modstate, keylet, bindlet):
+- (on_exec, has_args, mod_cmd, glob, more) = bind[depth]
+- cmd = keylet.modcmd if mod_cmd else keylet.keycmd
+-
+- if mod_cmd and modstate != mod_cmd:
+- return False
+-
+- if has_args:
+- if not cmd.startswith(glob):
+- return False
+-
+- args = [cmd[len(glob):],]
+-
+- elif cmd != glob:
+- return False
+-
+- else:
+- args = []
+-
+- if bind.is_global or (not more and depth == 0):
+- exec_bind(uzbl, bind, *args)
+- if not has_args:
+- uzbl.clear_current()
+-
+- return True
+-
+- elif more:
+- bindlet.stack(bind, args, depth)
+- (on_exec, has_args, mod_cmd, glob, more) = bind[depth+1]
+- if not on_exec and has_args and not glob and not more:
+- exec_bind(uzbl, bind, *(args+['',]))
+-
+- return False
+-
+- args = bindlet.args + args
+- exec_bind(uzbl, bind, *args)
+- if not has_args or on_exec:
+- del uzbl.config['mode']
+- bindlet.reset()
+-
+- return True
+-
+-
+-def key_event(uzbl, modstate, keylet, mod_cmd=False, on_exec=False):
+- bindlet = uzbl.bindlet
+- depth = bindlet.depth
+- for bind in bindlet.get_binds():
+- t = bind[depth]
+- if (bool(t[MOD_CMD]) != mod_cmd) or (t[ON_EXEC] != on_exec):
+- continue
+-
+- if match_and_exec(uzbl, bind, depth, modstate, keylet, bindlet):
+- return
+-
+- bindlet.after()
+-
+- # Return to the previous mode if the KEYCMD_EXEC keycmd doesn't match any
+- # binds in the stack mode.
+- if on_exec and not mod_cmd and depth and depth == bindlet.depth:
+- del uzbl.config['mode']
+-
+-
+-# plugin init hook
+-def init(uzbl):
+- '''Export functions and connect handlers to events.'''
+-
+- connect_dict(uzbl, {
+- 'BIND': parse_bind,
+- 'MODE_BIND': parse_mode_bind,
+- 'MODE_CHANGED': mode_changed,
+- })
+-
+- # Connect key related events to the key_event function.
+- events = [['KEYCMD_UPDATE', 'KEYCMD_EXEC'],
+- ['MODCMD_UPDATE', 'MODCMD_EXEC']]
+-
+- for mod_cmd in range(2):
+- for on_exec in range(2):
+- event = events[mod_cmd][on_exec]
+- connect(uzbl, event, key_event, bool(mod_cmd), bool(on_exec))
+-
+- export_dict(uzbl, {
+- 'bind': bind,
+- 'mode_bind': mode_bind,
+- 'bindlet': Bindlet(uzbl),
+- })
+-
+-# vi: set et ts=4:
+diff --git a/examples/data/plugins/cmd_expand.py b/examples/data/plugins/cmd_expand.py
+deleted file mode 100644
+index b007975..0000000
+--- a/examples/data/plugins/cmd_expand.py
++++ /dev/null
+@@ -1,40 +0,0 @@
+-def escape(str):
+- for (level, char) in [(3, '\\'), (2, "'"), (2, '"'), (1, '@')]:
+- str = str.replace(char, (level * '\\') + char)
+-
+- return str
+-
+-
+-def cmd_expand(uzbl, cmd, args):
+- '''Exports a function that provides the following
+- expansions in any uzbl command string:
+-
+- %s = replace('%s', ' '.join(args))
+- %r = replace('%r', "'%s'" % escaped(' '.join(args)))
+- %1 = replace('%1', arg[0])
+- %2 = replace('%2', arg[1])
+- %n = replace('%n', arg[n-1])
+- '''
+-
+- # Ensure (1) all string representable and (2) correct string encoding.
+- args = map(unicode, args)
+-
+- # Direct string replace.
+- if '%s' in cmd:
+- cmd = cmd.replace('%s', ' '.join(args))
+-
+- # Escaped and quoted string replace.
+- if '%r' in cmd:
+- cmd = cmd.replace('%r', "'%s'" % escape(' '.join(args)))
+-
+- # Arg index string replace.
+- for (index, arg) in enumerate(args):
+- index += 1
+- if '%%%d' % index in cmd:
+- cmd = cmd.replace('%%%d' % index, unicode(arg))
+-
+- return cmd
+-
+-# plugin init hook
+-def init(uzbl):
+- export(uzbl, 'cmd_expand', cmd_expand)
+diff --git a/examples/data/plugins/completion.py b/examples/data/plugins/completion.py
+deleted file mode 100644
+index e8c7f34..0000000
+--- a/examples/data/plugins/completion.py
++++ /dev/null
+@@ -1,179 +0,0 @@
+-'''Keycmd completion.'''
+-
+-import re
+-
+-# Completion level
+-NONE, ONCE, LIST, COMPLETE = range(4)
+-
+-# The reverse keyword finding re.
+-FIND_SEGMENT = re.compile("(\@[\w_]+|set[\s]+[\w_]+|[\w_]+)$").findall
+-
+-# Formats
+-LIST_FORMAT = "<span> %s </span>"
+-ITEM_FORMAT = "<span @hint_style>%s</span>%s"
+-
+-def escape(str):
+- return str.replace("@", "\@")
+-
+-
+-def get_incomplete_keyword(uzbl):
+- '''Gets the segment of the keycmd leading up to the cursor position and
+- uses a regular expression to search backwards finding parially completed
+- keywords or @variables. Returns a null string if the correct completion
+- conditions aren't met.'''
+-
+- keylet = uzbl.keylet
+- left_segment = keylet.keycmd[:keylet.cursor]
+- partial = (FIND_SEGMENT(left_segment) + ['',])[0].lstrip()
+- if partial.startswith('set '):
+- return ('@%s' % partial[4:].lstrip(), True)
+-
+- return (partial, False)
+-
+-
+-def stop_completion(uzbl, *args):
+- '''Stop command completion and return the level to NONE.'''
+-
+- uzbl.completion.level = NONE
+- del uzbl.config['completion_list']
+-
+-
+-def complete_completion(uzbl, partial, hint, set_completion=False):
+- '''Inject the remaining porition of the keyword into the keycmd then stop
+- the completioning.'''
+-
+- if set_completion:
+- remainder = "%s = " % hint[len(partial):]
+-
+- else:
+- remainder = "%s " % hint[len(partial):]
+-
+- uzbl.inject_keycmd(remainder)
+- stop_completion(uzbl)
+-
+-
+-def partial_completion(uzbl, partial, hint):
+- '''Inject a common portion of the hints into the keycmd.'''
+-
+- remainder = hint[len(partial):]
+- uzbl.inject_keycmd(remainder)
+-
+-
+-def update_completion_list(uzbl, *args):
+- '''Checks if the user still has a partially completed keyword under his
+- cursor then update the completion hints list.'''
+-
+- partial = get_incomplete_keyword(uzbl)[0]
+- if not partial:
+- return stop_completion(uzbl)
+-
+- if uzbl.completion.level < LIST:
+- return
+-
+- hints = filter(lambda h: h.startswith(partial), uzbl.completion)
+- if not hints:
+- del uzbl.config['completion_list']
+- return
+-
+- j = len(partial)
+- l = [ITEM_FORMAT % (escape(h[:j]), h[j:]) for h in sorted(hints)]
+- uzbl.config['completion_list'] = LIST_FORMAT % ' '.join(l)
+-
+-
+-def start_completion(uzbl, *args):
+-
+- comp = uzbl.completion
+- if comp.locked:
+- return
+-
+- (partial, set_completion) = get_incomplete_keyword(uzbl)
+- if not partial:
+- return stop_completion(uzbl)
+-
+- if comp.level < COMPLETE:
+- comp.level += 1
+-
+- hints = filter(lambda h: h.startswith(partial), comp)
+- if not hints:
+- return
+-
+- elif len(hints) == 1:
+- comp.lock()
+- complete_completion(uzbl, partial, hints[0], set_completion)
+- comp.unlock()
+- return
+-
+- elif partial in hints and comp.level == COMPLETE:
+- comp.lock()
+- complete_completion(uzbl, partial, partial, set_completion)
+- comp.unlock()
+- return
+-
+- smalllen, smallest = sorted([(len(h), h) for h in hints])[0]
+- common = ''
+- for i in range(len(partial), smalllen):
+- char, same = smallest[i], True
+- for hint in hints:
+- if hint[i] != char:
+- same = False
+- break
+-
+- if not same:
+- break
+-
+- common += char
+-
+- if common:
+- comp.lock()
+- partial_completion(uzbl, partial, partial+common)
+- comp.unlock()
+-
+- update_completion_list(uzbl)
+-
+-
+-def add_builtins(uzbl, builtins):
+- '''Pump the space delimited list of builtin commands into the
+- builtin list.'''
+-
+- uzbl.completion.update(builtins.split())
+-
+-
+-def add_config_key(uzbl, key, value):
+- '''Listen on the CONFIG_CHANGED event and add config keys to the variable
+- list for @var<Tab> like expansion support.'''
+-
+- uzbl.completion.add("@%s" % key)
+-
+-
+-class Completions(set):
+- def __init__(self):
+- set.__init__(self)
+- self.locked = False
+- self.level = NONE
+-
+- def lock(self):
+- self.locked = True
+-
+- def unlock(self):
+- self.locked = False
+-
+-
+-def init(uzbl):
+- '''Export functions and connect handlers to events.'''
+-
+- export_dict(uzbl, {
+- 'completion': Completions(),
+- 'start_completion': start_completion,
+- })
+-
+- connect_dict(uzbl, {
+- 'BUILTINS': add_builtins,
+- 'CONFIG_CHANGED': add_config_key,
+- 'KEYCMD_CLEARED': stop_completion,
+- 'KEYCMD_EXEC': stop_completion,
+- 'KEYCMD_UPDATE': update_completion_list,
+- 'START_COMPLETION': start_completion,
+- 'STOP_COMPLETION': stop_completion,
+- })
+-
+- uzbl.send('dump_config_as_events')
+diff --git a/examples/data/plugins/config.py b/examples/data/plugins/config.py
+deleted file mode 100644
+index c9bdf67..0000000
+--- a/examples/data/plugins/config.py
++++ /dev/null
+@@ -1,91 +0,0 @@
+-from re import compile
+-from types import BooleanType
+-from UserDict import DictMixin
+-
+-valid_key = compile('^[A-Za-z0-9_\.]+$').match
+-
+-class Config(DictMixin):
+- def __init__(self, uzbl):
+- self.uzbl = uzbl
+-
+- # Create the base dict and map allowed methods to `self`.
+- self.data = data = {}
+-
+- methods = ['__contains__', '__getitem__', '__iter__',
+- '__len__', 'get', 'has_key', 'items', 'iteritems',
+- 'iterkeys', 'itervalues', 'values']
+-
+- for method in methods:
+- setattr(self, method, getattr(data, method))
+-
+-
+- def __setitem__(self, key, value):
+- self.set(key, value)
+-
+- def __delitem__(self, key):
+- self.set(key)
+-
+- def update(self, other=None, **kwargs):
+- if other is None:
+- other = {}
+-
+- for (key, value) in dict(other).items() + kwargs.items():
+- self[key] = value
+-
+-
+- def set(self, key, value='', force=False):
+- '''Generates a `set <key> = <value>` command string to send to the
+- current uzbl instance.
+-
+- Note that the config dict isn't updated by this function. The config
+- dict is only updated after a successful `VARIABLE_SET ..` event
+- returns from the uzbl instance.'''
+-
+- assert valid_key(key)
+-
+- if type(value) == BooleanType:
+- value = int(value)
+-
+- else:
+- value = unicode(value)
+- assert '\n' not in value
+-
+- if not force and key in self and self[key] == value:
+- return
+-
+- self.uzbl.send(u'set %s = %s' % (key, value))
+-
+-
+-def parse_set_event(uzbl, args):
+- '''Parse `VARIABLE_SET <var> <type> <value>` event and load the
+- (key, value) pair into the `uzbl.config` dict.'''
+-
+- (key, type, raw_value) = (args.split(' ', 2) + ['',])[:3]
+-
+- assert valid_key(key)
+- assert type in types
+-
+- new_value = types[type](raw_value)
+- old_value = uzbl.config.get(key, None)
+-
+- # Update new value.
+- uzbl.config.data[key] = new_value
+-
+- if old_value != new_value:
+- uzbl.event('CONFIG_CHANGED', key, new_value)
+-
+- # Cleanup null config values.
+- if type == 'str' and not new_value:
+- del uzbl.config.data[key]
+-
+-
+-# plugin init hook
+-def init(uzbl):
+- global types
+- types = {'int': int, 'float': float, 'str': unquote}
+- export(uzbl, 'config', Config(uzbl))
+- connect(uzbl, 'VARIABLE_SET', parse_set_event)
+-
+-# plugin cleanup hook
+-def cleanup(uzbl):
+- uzbl.config.data.clear()
+diff --git a/examples/data/plugins/cookies.py b/examples/data/plugins/cookies.py
+deleted file mode 100644
+index bf59e96..0000000
+--- a/examples/data/plugins/cookies.py
++++ /dev/null
+@@ -1,222 +0,0 @@
+-""" Basic cookie manager
+- forwards cookies to all other instances connected to the event manager"""
+-
+-from collections import defaultdict
+-import os, re, stat
+-
+-# these are symbolic names for the components of the cookie tuple
+-symbolic = {'domain': 0, 'path':1, 'name':2, 'value':3, 'scheme':4, 'expires':5}
+-
+-# allows for partial cookies
+-# ? allow wildcard in key
+-def match(key, cookie):
+- for k,c in zip(key,cookie):
+- if k != c:
+- return False
+- return True
+-
+-class NullStore(object):
+- def add_cookie(self, rawcookie, cookie):
+- pass
+-
+- def delete_cookie(self, rkey, key):
+- pass
+-
+-class ListStore(list):
+- def add_cookie(self, rawcookie, cookie):
+- self.append(rawcookie)
+-
+- def delete_cookie(self, rkey, key):
+- self[:] = [x for x in self if not match(key, splitquoted(x))]
+-
+-class TextStore(object):
+- def __init__(self, filename):
+- self.filename = filename
+- try:
+- # make sure existing cookie jar is not world-open
+- perm_mode = os.stat(self.filename).st_mode
+- if (perm_mode & (stat.S_IRWXO | stat.S_IRWXG)) > 0:
+- safe_perm = stat.S_IMODE(perm_mode) & ~(stat.S_IRWXO | stat.S_IRWXG)
+- os.chmod(self.filename, safe_perm)
+- except OSError:
+- pass
+-
+- def as_event(self, cookie):
+- """Convert cookie.txt row to uzbls cookie event format"""
+- scheme = {
+- 'TRUE' : 'https',
+- 'FALSE' : 'http'
+- }
+- extra = ''
+- if cookie[0].startswith("#HttpOnly_"):
+- extra = 'Only'
+- domain = cookie[0][len("#HttpOnly_"):]
+- elif cookie[0].startswith('#'):
+- return None
+- else:
+- domain = cookie[0]
+- try:
+- return (domain,
+- cookie[2],
+- cookie[5],
+- cookie[6],
+- scheme[cookie[3]] + extra,
+- cookie[4])
+- except (KeyError,IndexError):
+- # Let malformed rows pass through like comments
+- return None
+-
+- def as_file(self, cookie):
+- """Convert cookie event to cookie.txt row"""
+- secure = {
+- 'https' : 'TRUE',
+- 'http' : 'FALSE',
+- 'httpsOnly' : 'TRUE',
+- 'httpOnly' : 'FALSE'
+- }
+- http_only = {
+- 'https' : '',
+- 'http' : '',
+- 'httpsOnly' : '#HttpOnly_',
+- 'httpOnly' : '#HttpOnly_'
+- }
+- return (http_only[cookie[4]] + cookie[0],
+- 'TRUE' if cookie[0].startswith('.') else 'FALSE',
+- cookie[1],
+- secure[cookie[4]],
+- cookie[5],
+- cookie[2],
+- cookie[3])
+-
+- def add_cookie(self, rawcookie, cookie):
+- assert len(cookie) == 6
+-
+- # delete equal cookies (ignoring expire time, value and secure flag)
+- self.delete_cookie(None, cookie[:-3])
+-
+- # restrict umask before creating the cookie jar
+- curmask=os.umask(0)
+- os.umask(curmask| stat.S_IRWXO | stat.S_IRWXG)
+-
+- first = not os.path.exists(self.filename)
+- with open(self.filename, 'a') as f:
+- if first:
+- print >> f, "# HTTP Cookie File"
+- print >> f, '\t'.join(self.as_file(cookie))
+- os.umask(curmask)
+-
+- def delete_cookie(self, rkey, key):
+- if not os.path.exists(self.filename):
+- return
+-
+- # restrict umask before creating the cookie jar
+- curmask=os.umask(0)
+- os.umask(curmask | stat.S_IRWXO | stat.S_IRWXG)
+-
+- # read all cookies
+- with open(self.filename, 'r') as f:
+- cookies = f.readlines()
+-
+- # write those that don't match the cookie to delete
+- with open(self.filename, 'w') as f:
+- for l in cookies:
+- c = self.as_event(l.split('\t'))
+- if c is None or not match(key, c):
+- print >> f, l,
+- os.umask(curmask)
+-
+-xdg_data_home = os.environ.get('XDG_DATA_HOME', os.path.join(os.environ['HOME'], '.local/share'))
+-DefaultStore = TextStore(os.path.join(xdg_data_home, 'uzbl/cookies.txt'))
+-SessionStore = TextStore(os.path.join(xdg_data_home, 'uzbl/session-cookies.txt'))
+-
+-def match_list(_list, cookie):
+- for matcher in _list:
+- for component, match in matcher:
+- if match(cookie[component]) is None:
+- break
+- else:
+- return True
+- return False
+-
+-# accept a cookie only when:
+-# a. there is no whitelist and the cookie is in the blacklist
+-# b. the cookie is in the whitelist and not in the blacklist
+-def accept_cookie(uzbl, cookie):
+- if uzbl.cookie_whitelist:
+- if match_list(uzbl.cookie_whitelist, cookie):
+- return not match_list(uzbl.cookie_blacklist, cookie)
+- return False
+-
+- return not match_list(uzbl.cookie_blacklist, cookie)
+-
+-def expires_with_session(uzbl, cookie):
+- return cookie[5] == ''
+-
+-def get_recipents(uzbl):
+- """ get a list of Uzbl instances to send the cookie too. """
+- # This could be a lot more interesting
+- return [u for u in uzbl.parent.uzbls.values() if u is not uzbl]
+-
+-def get_store(uzbl, session=False):
+- if session:
+- return SessionStore
+- return DefaultStore
+-
+-def add_cookie(uzbl, cookie):
+- splitted = splitquoted(cookie)
+- if accept_cookie(uzbl, splitted):
+- for u in get_recipents(uzbl):
+- u.send('add_cookie %s' % cookie)
+-
+- get_store(uzbl, expires_with_session(uzbl, splitted)).add_cookie(cookie, splitted)
+- else:
+- logger.debug('cookie %r is blacklisted' % splitted)
+- uzbl.send('delete_cookie %s' % cookie)
+-
+-def delete_cookie(uzbl, cookie):
+- for u in get_recipents(uzbl):
+- u.send('delete_cookie %s' % cookie)
+-
+- splitted = splitquoted(cookie)
+- if len(splitted) == 6:
+- get_store(uzbl, expires_with_session(uzbl, splitted)).delete_cookie(cookie, splitted)
+- else:
+- for store in set([get_store(uzbl, session) for session in (True, False)]):
+- store.delete_cookie(cookie, splitted)
+-
+-# add a cookie matcher to a whitelist or a blacklist.
+-# a matcher is a list of (component, re) tuples that matches a cookie when the
+-# "component" part of the cookie matches the regular expression "re".
+-# "component" is one of the keys defined in the variable "symbolic" above,
+-# or the index of a component of a cookie tuple.
+-def add_cookie_matcher(_list, arg):
+- args = splitquoted(arg)
+- mlist = []
+- for (component, regexp) in zip(args[0::2], args[1::2]):
+- try:
+- component = symbolic[component]
+- except KeyError:
+- component = int(component)
+- assert component <= 5
+- mlist.append((component, re.compile(regexp).search))
+- _list.append(mlist)
+-
+-def blacklist(uzbl, arg):
+- add_cookie_matcher(uzbl.cookie_blacklist, arg)
+-
+-def whitelist(uzbl, arg):
+- add_cookie_matcher(uzbl.cookie_whitelist, arg)
+-
+-def init(uzbl):
+- connect_dict(uzbl, {
+- 'ADD_COOKIE': add_cookie,
+- 'DELETE_COOKIE': delete_cookie,
+- 'BLACKLIST_COOKIE': blacklist,
+- 'WHITELIST_COOKIE': whitelist
+- })
+- export_dict(uzbl, {
+- 'cookie_blacklist' : [],
+- 'cookie_whitelist' : []
+- })
+-
+-# vi: set et ts=4:
+diff --git a/examples/data/plugins/downloads.py b/examples/data/plugins/downloads.py
+deleted file mode 100644
+index 8d796ce..0000000
+--- a/examples/data/plugins/downloads.py
++++ /dev/null
+@@ -1,77 +0,0 @@
+-# this plugin does a very simple display of download progress. to use it, add
+-# @downloads to your status_format.
+-
+-import os
+-ACTIVE_DOWNLOADS = {}
+-
+-# after a download's status has changed this is called to update the status bar
+-def update_download_section(uzbl):
+- global ACTIVE_DOWNLOADS
+-
+- if len(ACTIVE_DOWNLOADS):
+- # add a newline before we list downloads
+- result = ' downloads:'
+- for path in ACTIVE_DOWNLOADS:
+- # add each download
+- fn = os.path.basename(path)
+- progress, = ACTIVE_DOWNLOADS[path]
+-
+- dl = " %s (%d%%)" % (fn, progress * 100)
+-
+- # replace entities to make sure we don't break our markup
+- # (this could be done with an @[]@ expansion in uzbl, but then we
+- # can't use the above to make a new line)
+- dl = dl.replace("&", "&").replace("<", "<")
+- result += dl
+- else:
+- result = ''
+-
+- # and the result gets saved to an uzbl variable that can be used in
+- # status_format
+- if uzbl.config.get('downloads', '') != result:
+- uzbl.config['downloads'] = result
+-
+-def download_started(uzbl, args):
+- # parse the arguments
+- args = splitquoted(args)
+- destination_path = args[0]
+-
+- # add to the list of active downloads
+- global ACTIVE_DOWNLOADS
+- ACTIVE_DOWNLOADS[destination_path] = (0.0,)
+-
+- # update the progress
+- update_download_section(uzbl)
+-
+-def download_progress(uzbl, args):
+- # parse the arguments
+- args = splitquoted(args)
+- destination_path = args[0]
+- progress = float(args[1])
+-
+- # update the progress
+- global ACTIVE_DOWNLOADS
+- ACTIVE_DOWNLOADS[destination_path] = (progress,)
+-
+- # update the status bar variable
+- update_download_section(uzbl)
+-
+-def download_complete(uzbl, args):
+- # parse the arguments
+- args = splitquoted(args)
+- destination_path = args[0]
+-
+- # remove from the list of active downloads
+- global ACTIVE_DOWNLOADS
+- del ACTIVE_DOWNLOADS[destination_path]
+-
+- # update the status bar variable
+- update_download_section(uzbl)
+-
+-# plugin init hook
+-def init(uzbl):
+- connect_dict(uzbl, {
+- 'DOWNLOAD_STARTED': download_started,
+- 'DOWNLOAD_PROGRESS': download_progress,
+- 'DOWNLOAD_COMPLETE': download_complete,
+- })
+diff --git a/examples/data/plugins/history.py b/examples/data/plugins/history.py
+deleted file mode 100644
+index f42f86f..0000000
+--- a/examples/data/plugins/history.py
++++ /dev/null
+@@ -1,129 +0,0 @@
+-import random
+-
+-shared_history = {'':[]}
+-
+-class History(object):
+- def __init__(self, uzbl):
+- self.uzbl = uzbl
+- self._temporary = []
+- self.prompt = ''
+- self.cursor = None
+- self.__temp_tail = False
+- self.search_key = None
+-
+- def prev(self):
+- if self.cursor is None:
+- self.cursor = len(self) - 1
+- else:
+- self.cursor -= 1
+-
+- if self.search_key:
+- while self.cursor >= 0 and self.search_key not in self[self.cursor]:
+- self.cursor -= 1
+-
+- if self.cursor < 0 or len(self) == 0:
+- self.cursor = -1
+- return random.choice(end_messages)
+-
+- return self[self.cursor]
+-
+- def next(self):
+- if self.cursor is None:
+- return ''
+-
+- self.cursor += 1
+-
+- if self.search_key:
+- while self.cursor < len(self) and self.search_key not in self[self.cursor]:
+- self.cursor += 1
+-
+- if self.cursor >= len(shared_history[self.prompt]):
+- self.cursor = None
+- self.search_key = None
+-
+- if self._temporary:
+- return self._temporary.pop()
+- return ''
+-
+- return self[self.cursor]
+-
+- def change_prompt(self, prompt):
+- self.prompt = prompt
+- self._temporary = []
+- self.__temp_tail = False
+- if prompt not in shared_history:
+- shared_history[prompt] = []
+-
+- def search(self, key):
+- self.search_key = key
+- self.cursor = None
+-
+- def add(self, cmd):
+- if self._temporary:
+- self._temporary.pop()
+-
+- shared_history[self.prompt].append(cmd)
+- self.cursor = None
+- self.search_key = None
+-
+- def add_temporary(self, cmd):
+- assert not self._temporary
+-
+- self._temporary.append(cmd)
+- self.cursor = len(self) - 1
+-
+- def __getitem__(self, i):
+- if i < len(shared_history[self.prompt]):
+- return shared_history[self.prompt][i]
+- return self._temporary[i-len(shared_history)+1]
+-
+- def __len__(self):
+- return len(shared_history[self.prompt]) + len(self._temporary)
+-
+- def __str__(self):
+- return "(History %s, %s)" % (self.cursor, self.prompt)
+-
+-def keycmd_exec(uzbl, modstate, keylet):
+- cmd = keylet.get_keycmd()
+- if cmd:
+- uzbl.history.add(cmd)
+-
+-def history_prev(uzbl, _x):
+- cmd = uzbl.keylet.get_keycmd()
+- if uzbl.history.cursor is None and cmd:
+- uzbl.history.add_temporary(cmd)
+-
+- uzbl.set_keycmd(uzbl.history.prev())
+- uzbl.logger.debug('PREV %s' % uzbl.history)
+-
+-def history_next(uzbl, _x):
+- cmd = uzbl.keylet.get_keycmd()
+-
+- uzbl.set_keycmd(uzbl.history.next())
+- uzbl.logger.debug('NEXT %s' % uzbl.history)
+-
+-def history_search(uzbl, key):
+- uzbl.history.search(key)
+- uzbl.send('event HISTORY_PREV')
+- uzbl.logger.debug('SEARCH %s %s' % (key, uzbl.history))
+-
+-end_messages = ('Look behind you, A three-headed monkey!', 'error #4: static from nylon underwear.', 'error #5: static from plastic slide rules.', 'error #6: global warming.', 'error #9: doppler effect.', 'error #16: somebody was calculating pi on the server.', 'error #19: floating point processor overflow.', 'error #21: POSIX compliance problem.', 'error #25: Decreasing electron flux.', 'error #26: first Saturday after first full moon in Winter.', 'error #64: CPU needs recalibration.', 'error #116: the real ttys became pseudo ttys and vice-versa.', 'error #229: wrong polarity of neutron flow.', 'error #330: quantum decoherence.', 'error #388: Bad user karma.', 'error #407: Route flapping at the NAP.', 'error #435: Internet shut down due to maintenance.')
+-
+-# plugin init hook
+-def init(uzbl):
+- connect_dict(uzbl, {
+- 'KEYCMD_EXEC': keycmd_exec,
+- 'HISTORY_PREV': history_prev,
+- 'HISTORY_NEXT': history_next,
+- 'HISTORY_SEARCH': history_search
+- })
+-
+- export_dict(uzbl, {
+- 'history' : History(uzbl)
+- })
+-
+-# plugin after hook
+-def after(uzbl):
+- uzbl.on_set('keycmd_prompt', lambda uzbl, k, v: uzbl.history.change_prompt(v))
+-
+-# vi: set et ts=4:
+diff --git a/examples/data/plugins/keycmd.py b/examples/data/plugins/keycmd.py
+deleted file mode 100644
+index 1bb70e3..0000000
+--- a/examples/data/plugins/keycmd.py
++++ /dev/null
+@@ -1,423 +0,0 @@
+-import re
+-
+-# Keycmd format which includes the markup for the cursor.
+-KEYCMD_FORMAT = "%s<span @cursor_style>%s</span>%s"
+-MODCMD_FORMAT = "<span> %s </span>"
+-
+-
+-def escape(str):
+- for char in ['\\', '@']:
+- str = str.replace(char, '\\'+char)
+-
+- return str
+-
+-
+-def uzbl_escape(str):
+- return "@[%s]@" % escape(str) if str else ''
+-
+-
+-class Keylet(object):
+- '''Small per-instance object that tracks characters typed.'''
+-
+- def __init__(self):
+- # Modcmd tracking
+- self.modcmd = ''
+- self.is_modcmd = False
+-
+- # Keycmd tracking
+- self.keycmd = ''
+- self.cursor = 0
+-
+- self.modmaps = {}
+- self.ignores = {}
+-
+-
+- def get_keycmd(self):
+- '''Get the keycmd-part of the keylet.'''
+-
+- return self.keycmd
+-
+-
+- def get_modcmd(self):
+- '''Get the modcmd-part of the keylet.'''
+-
+- if not self.is_modcmd:
+- return ''
+-
+- return self.modcmd
+-
+-
+- def modmap_key(self, key):
+- '''Make some obscure names for some keys friendlier.'''
+-
+- if key in self.modmaps:
+- return self.modmaps[key]
+-
+- elif key.endswith('_L') or key.endswith('_R'):
+- # Remove left-right discrimination and try again.
+- return self.modmap_key(key[:-2])
+-
+- else:
+- return key
+-
+-
+- def key_ignored(self, key):
+- '''Check if the given key is ignored by any ignore rules.'''
+-
+- for (glob, match) in self.ignores.items():
+- if match(key):
+- return True
+-
+- return False
+-
+-
+- def __repr__(self):
+- '''Return a string representation of the keylet.'''
+-
+- l = []
+- if self.is_modcmd:
+- l.append('modcmd=%r' % self.get_modcmd())
+-
+- if self.keycmd:
+- l.append('keycmd=%r' % self.get_keycmd())
+-
+- return '<keylet(%s)>' % ', '.join(l)
+-
+-
+-def add_modmap(uzbl, key, map):
+- '''Add modmaps.
+-
+- Examples:
+- set modmap = request MODMAP
+- @modmap <Control> <Ctrl>
+- @modmap <ISO_Left_Tab> <Shift-Tab>
+- ...
+-
+- Then:
+- @bind <Shift-Tab> = <command1>
+- @bind <Ctrl>x = <command2>
+- ...
+-
+- '''
+-
+- assert len(key)
+- modmaps = uzbl.keylet.modmaps
+-
+- modmaps[key.strip('<>')] = map.strip('<>')
+- uzbl.event("NEW_MODMAP", key, map)
+-
+-
+-def modmap_parse(uzbl, map):
+- '''Parse a modmap definiton.'''
+-
+- split = [s.strip() for s in map.split(' ') if s.split()]
+-
+- if not split or len(split) > 2:
+- raise Exception('Invalid modmap arugments: %r' % map)
+-
+- add_modmap(uzbl, *split)
+-
+-
+-def add_key_ignore(uzbl, glob):
+- '''Add an ignore definition.
+-
+- Examples:
+- set ignore_key = request IGNORE_KEY
+- @ignore_key <Shift>
+- @ignore_key <ISO_*>
+- ...
+- '''
+-
+- assert len(glob) > 1
+- ignores = uzbl.keylet.ignores
+-
+- glob = "<%s>" % glob.strip("<> ")
+- restr = glob.replace('*', '[^\s]*')
+- match = re.compile(restr).match
+-
+- ignores[glob] = match
+- uzbl.event('NEW_KEY_IGNORE', glob)
+-
+-
+-def clear_keycmd(uzbl, *args):
+- '''Clear the keycmd for this uzbl instance.'''
+-
+- k = uzbl.keylet
+- k.keycmd = ''
+- k.cursor = 0
+- del uzbl.config['keycmd']
+- uzbl.event('KEYCMD_CLEARED')
+-
+-
+-def clear_modcmd(uzbl):
+- '''Clear the modcmd for this uzbl instance.'''
+-
+- k = uzbl.keylet
+- k.modcmd = ''
+- k.is_modcmd = False
+-
+- del uzbl.config['modcmd']
+- uzbl.event('MODCMD_CLEARED')
+-
+-
+-def clear_current(uzbl):
+- '''Clear the modcmd if is_modcmd else clear keycmd.'''
+-
+- if uzbl.keylet.is_modcmd:
+- clear_modcmd(uzbl)
+-
+- else:
+- clear_keycmd(uzbl)
+-
+-
+-def update_event(uzbl, modstate, k, execute=True):
+- '''Raise keycmd & modcmd update events.'''
+-
+- keycmd, modcmd = k.get_keycmd(), ''.join(modstate) + k.get_modcmd()
+-
+- if k.is_modcmd:
+- logger.debug('modcmd_update, %s' % modcmd)
+- uzbl.event('MODCMD_UPDATE', modstate, k)
+-
+- else:
+- logger.debug('keycmd_update, %s' % keycmd)
+- uzbl.event('KEYCMD_UPDATE', modstate, k)
+-
+- if uzbl.config.get('modcmd_updates', '1') == '1':
+- new_modcmd = ''.join(modstate) + k.get_modcmd()
+- if not new_modcmd or not k.is_modcmd:
+- del uzbl.config['modcmd']
+-
+- elif new_modcmd == modcmd:
+- uzbl.config['modcmd'] = MODCMD_FORMAT % uzbl_escape(modcmd)
+-
+- if uzbl.config.get('keycmd_events', '1') != '1':
+- return
+-
+- new_keycmd = k.get_keycmd()
+- if not new_keycmd:
+- del uzbl.config['keycmd']
+-
+- elif new_keycmd == keycmd:
+- # Generate the pango markup for the cursor in the keycmd.
+- curchar = keycmd[k.cursor] if k.cursor < len(keycmd) else ' '
+- chunks = [keycmd[:k.cursor], curchar, keycmd[k.cursor+1:]]
+- value = KEYCMD_FORMAT % tuple(map(uzbl_escape, chunks))
+-
+- uzbl.config['keycmd'] = value
+-
+-
+-def inject_str(str, index, inj):
+- '''Inject a string into string at at given index.'''
+-
+- return "%s%s%s" % (str[:index], inj, str[index:])
+-
+-
+-def parse_key_event(uzbl, key):
+- ''' Build a set from the modstate part of the event, and pass all keys through modmap '''
+- keylet = uzbl.keylet
+-
+- modstate, key = splitquoted(key)
+- modstate = set(['<%s>' % keylet.modmap_key(k) for k in modstate.split('|') if k])
+-
+- key = keylet.modmap_key(key)
+- return modstate, key
+-
+-
+-def key_press(uzbl, key):
+- '''Handle KEY_PRESS events. Things done by this function include:
+-
+- 1. Ignore all shift key presses (shift can be detected by capital chars)
+- 2. In non-modcmd mode:
+- a. append char to keycmd
+- 3. If not in modcmd mode and a modkey was pressed set modcmd mode.
+- 4. Keycmd is updated and events raised if anything is changed.'''
+-
+- k = uzbl.keylet
+- modstate, key = parse_key_event(uzbl, key)
+- k.is_modcmd = any(not k.key_ignored(m) for m in modstate)
+-
+- logger.debug('key press modstate=%s' % str(modstate))
+- if key.lower() == 'space' and not k.is_modcmd and k.keycmd:
+- k.keycmd = inject_str(k.keycmd, k.cursor, ' ')
+- k.cursor += 1
+-
+- elif not k.is_modcmd and len(key) == 1:
+- if uzbl.config.get('keycmd_events', '1') != '1':
+- # TODO, make a note on what's going on here
+- k.keycmd = ''
+- k.cursor = 0
+- del uzbl.config['keycmd']
+- return
+-
+- k.keycmd = inject_str(k.keycmd, k.cursor, key)
+- k.cursor += 1
+-
+- elif len(key) == 1:
+- k.modcmd += key
+-
+- else:
+- if not k.key_ignored('<%s>' % key):
+- modstate.add('<%s>' % key)
+- k.is_modcmd = True
+-
+- update_event(uzbl, modstate, k)
+-
+-
+-def key_release(uzbl, key):
+- '''Respond to KEY_RELEASE event. Things done by this function include:
+-
+- 1. If in a mod-command then raise a MODCMD_EXEC.
+- 2. Update the keycmd uzbl variable if anything changed.'''
+- k = uzbl.keylet
+- modstate, key = parse_key_event(uzbl, key)
+-
+- if len(key) > 1:
+- if k.is_modcmd:
+- uzbl.event('MODCMD_EXEC', modstate, k)
+-
+- clear_modcmd(uzbl)
+-
+-
+-def set_keycmd(uzbl, keycmd):
+- '''Allow setting of the keycmd externally.'''
+-
+- k = uzbl.keylet
+- k.keycmd = keycmd
+- k.cursor = len(keycmd)
+- update_event(uzbl, set(), k, False)
+-
+-
+-def inject_keycmd(uzbl, keycmd):
+- '''Allow injecting of a string into the keycmd at the cursor position.'''
+-
+- k = uzbl.keylet
+- k.keycmd = inject_str(k.keycmd, k.cursor, keycmd)
+- k.cursor += len(keycmd)
+- update_event(uzbl, set(), k, False)
+-
+-
+-def append_keycmd(uzbl, keycmd):
+- '''Allow appening of a string to the keycmd.'''
+-
+- k = uzbl.keylet
+- k.keycmd += keycmd
+- k.cursor = len(k.keycmd)
+- update_event(uzbl, set(), k, False)
+-
+-
+-def keycmd_strip_word(uzbl, seps):
+- ''' Removes the last word from the keycmd, similar to readline ^W '''
+-
+- seps = seps or ' '
+- k = uzbl.keylet
+- if not k.keycmd:
+- return
+-
+- head, tail = k.keycmd[:k.cursor].rstrip(seps), k.keycmd[k.cursor:]
+- rfind = -1
+- for sep in seps:
+- p = head.rfind(sep)
+- if p >= 0 and rfind < p + 1:
+- rfind = p + 1
+- if rfind == len(head) and head[-1] in seps:
+- rfind -= 1
+- head = head[:rfind] if rfind + 1 else ''
+- k.keycmd = head + tail
+- k.cursor = len(head)
+- update_event(uzbl, set(), k, False)
+-
+-
+-def keycmd_backspace(uzbl, *args):
+- '''Removes the character at the cursor position in the keycmd.'''
+-
+- k = uzbl.keylet
+- if not k.keycmd or not k.cursor:
+- return
+-
+- k.keycmd = k.keycmd[:k.cursor-1] + k.keycmd[k.cursor:]
+- k.cursor -= 1
+- update_event(uzbl, set(), k, False)
+-
+-
+-def keycmd_delete(uzbl, *args):
+- '''Removes the character after the cursor position in the keycmd.'''
+-
+- k = uzbl.keylet
+- if not k.keycmd:
+- return
+-
+- k.keycmd = k.keycmd[:k.cursor] + k.keycmd[k.cursor+1:]
+- update_event(uzbl, set(), k, False)
+-
+-
+-def keycmd_exec_current(uzbl, *args):
+- '''Raise a KEYCMD_EXEC with the current keylet and then clear the
+- keycmd.'''
+-
+- uzbl.event('KEYCMD_EXEC', set(), uzbl.keylet)
+- clear_keycmd(uzbl)
+-
+-
+-def set_cursor_pos(uzbl, index):
+- '''Allow setting of the cursor position externally. Supports negative
+- indexing and relative stepping with '+' and '-'.'''
+-
+- k = uzbl.keylet
+- if index == '-':
+- cursor = k.cursor - 1
+-
+- elif index == '+':
+- cursor = k.cursor + 1
+-
+- else:
+- cursor = int(index.strip())
+- if cursor < 0:
+- cursor = len(k.keycmd) + cursor + 1
+-
+- if cursor < 0:
+- cursor = 0
+-
+- if cursor > len(k.keycmd):
+- cursor = len(k.keycmd)
+-
+- k.cursor = cursor
+- update_event(uzbl, set(), k, False)
+-
+-
+-# plugin init hook
+-def init(uzbl):
+- '''Export functions and connect handlers to events.'''
+-
+- connect_dict(uzbl, {
+- 'APPEND_KEYCMD': append_keycmd,
+- 'IGNORE_KEY': add_key_ignore,
+- 'INJECT_KEYCMD': inject_keycmd,
+- 'KEYCMD_BACKSPACE': keycmd_backspace,
+- 'KEYCMD_DELETE': keycmd_delete,
+- 'KEYCMD_EXEC_CURRENT': keycmd_exec_current,
+- 'KEYCMD_STRIP_WORD': keycmd_strip_word,
+- 'KEYCMD_CLEAR': clear_keycmd,
+- 'KEY_PRESS': key_press,
+- 'KEY_RELEASE': key_release,
+- 'MOD_PRESS': key_press,
+- 'MOD_RELEASE': key_release,
+- 'MODMAP': modmap_parse,
+- 'SET_CURSOR_POS': set_cursor_pos,
+- 'SET_KEYCMD': set_keycmd,
+- })
+-
+- export_dict(uzbl, {
+- 'add_key_ignore': add_key_ignore,
+- 'add_modmap': add_modmap,
+- 'append_keycmd': append_keycmd,
+- 'clear_current': clear_current,
+- 'clear_keycmd': clear_keycmd,
+- 'clear_modcmd': clear_modcmd,
+- 'inject_keycmd': inject_keycmd,
+- 'keylet': Keylet(),
+- 'set_cursor_pos': set_cursor_pos,
+- 'set_keycmd': set_keycmd,
+- })
+-
+-# vi: set et ts=4:
+diff --git a/examples/data/plugins/mode.py b/examples/data/plugins/mode.py
+deleted file mode 100644
+index e0de706..0000000
+--- a/examples/data/plugins/mode.py
++++ /dev/null
+@@ -1,68 +0,0 @@
+-from collections import defaultdict
+-
+-def parse_mode_config(uzbl, args):
+- '''Parse `MODE_CONFIG <mode> <var> = <value>` event and update config if
+- the `<mode>` is the current mode.'''
+-
+- ustrip = unicode.strip
+- args = unicode(args)
+-
+- assert args.strip(), "missing mode config args"
+- (mode, args) = map(ustrip, (args.strip().split(' ', 1) + ['',])[:2])
+-
+- assert args.strip(), "missing mode config set arg"
+- (key, value) = map(ustrip, (args.strip().split('=', 1) + [None,])[:2])
+- assert key and value is not None, "invalid mode config set syntax"
+-
+- uzbl.mode_config[mode][key] = value
+- if uzbl.config.get('mode', None) == mode:
+- uzbl.config[key] = value
+-
+-
+-def default_mode_updated(uzbl, var, mode):
+- if mode and not uzbl.config.get('mode', None):
+- logger.debug('setting mode to default %r' % mode)
+- uzbl.config['mode'] = mode
+-
+-
+-def mode_updated(uzbl, var, mode):
+- if not mode:
+- mode = uzbl.config.get('default_mode', 'command')
+- logger.debug('setting mode to default %r' % mode)
+- uzbl.config['mode'] = mode
+- return
+-
+- # Load mode config
+- mode_config = uzbl.mode_config.get(mode, None)
+- if mode_config:
+- uzbl.config.update(mode_config)
+-
+- uzbl.send('event MODE_CONFIRM %s' % mode)
+-
+-
+-def confirm_change(uzbl, mode):
+- if mode and uzbl.config.get('mode', None) == mode:
+- uzbl.event('MODE_CHANGED', mode)
+-
+-
+-# plugin init hook
+-def init(uzbl):
+- require('config')
+- require('on_set')
+-
+- # Usage `uzbl.mode_config[mode][key] = value`
+- export(uzbl, 'mode_config', defaultdict(dict))
+-
+- connect_dict(uzbl, {
+- 'MODE_CONFIG': parse_mode_config,
+- 'MODE_CONFIRM': confirm_change,
+- })
+-
+-# plugin after hook
+-def after(uzbl):
+- uzbl.on_set('mode', mode_updated)
+- uzbl.on_set('default_mode', default_mode_updated)
+-
+-# plugin cleanup hook
+-def cleanup(uzbl):
+- uzbl.mode_config.clear()
+diff --git a/examples/data/plugins/on_event.py b/examples/data/plugins/on_event.py
+deleted file mode 100644
+index 32f09e2..0000000
+--- a/examples/data/plugins/on_event.py
++++ /dev/null
+@@ -1,88 +0,0 @@
+-'''Plugin provides arbitrary binding of uzbl events to uzbl commands.
+-
+-Formatting options:
+- %s = space separated string of the arguments
+- %r = escaped and quoted version of %s
+- %1 = argument 1
+- %2 = argument 2
+- %n = argument n
+-
+-Usage:
+- request ON_EVENT LINK_HOVER set selected_uri = $1
+- --> LINK_HOVER http://uzbl.org/
+- <-- set selected_uri = http://uzbl.org/
+-
+- request ON_EVENT CONFIG_CHANGED print Config changed: %1 = %2
+- --> CONFIG_CHANGED selected_uri http://uzbl.org/
+- <-- print Config changed: selected_uri = http://uzbl.org/
+-'''
+-
+-import sys
+-import re
+-
+-def event_handler(uzbl, *args, **kargs):
+- '''This function handles all the events being watched by various
+- on_event definitions and responds accordingly.'''
+-
+- # Could be connected to a EM internal event that can use anything as args
+- if len(args) == 1 and isinstance(args[0], basestring):
+- args = splitquoted(args[0])
+-
+- events = uzbl.on_events
+- event = kargs['on_event']
+- if event not in events:
+- return
+-
+- commands = events[event]
+- cmd_expand = uzbl.cmd_expand
+- for cmd in commands:
+- cmd = cmd_expand(cmd, args)
+- uzbl.send(cmd)
+-
+-
+-def on_event(uzbl, event, cmd):
+- '''Add a new event to watch and respond to.'''
+-
+- event = event.upper()
+- events = uzbl.on_events
+- if event not in events:
+- connect(uzbl, event, event_handler, on_event=event)
+- events[event] = []
+-
+- cmds = events[event]
+- if cmd not in cmds:
+- cmds.append(cmd)
+-
+-
+-def parse_on_event(uzbl, args):
+- '''Parse ON_EVENT events and pass them to the on_event function.
+-
+- Syntax: "event ON_EVENT <EVENT_NAME> commands".'''
+-
+- args = args.strip()
+- assert args, 'missing on event arguments'
+-
+- (event, command) = (args.split(' ', 1) + ['',])[:2]
+- assert event and command, 'missing on event command'
+- on_event(uzbl, event, command)
+-
+-
+-# plugin init hook
+-def init(uzbl):
+- '''Export functions and connect handlers to events.'''
+-
+- connect(uzbl, 'ON_EVENT', parse_on_event)
+-
+- export_dict(uzbl, {
+- 'on_event': on_event,
+- 'on_events': {},
+- })
+-
+-# plugin cleanup hook
+-def cleanup(uzbl):
+- for handlers in uzbl.on_events.values():
+- del handlers[:]
+-
+- uzbl.on_events.clear()
+-
+-# vi: set et ts=4:
+diff --git a/examples/data/plugins/on_set.py b/examples/data/plugins/on_set.py
+deleted file mode 100644
+index 130b816..0000000
+--- a/examples/data/plugins/on_set.py
++++ /dev/null
+@@ -1,92 +0,0 @@
+-from re import compile
+-from functools import partial
+-
+-valid_glob = compile('^[A-Za-z0-9_\*\.]+$').match
+-
+-def make_matcher(glob):
+- '''Make matcher function from simple glob.'''
+-
+- pattern = "^%s$" % glob.replace('*', '[^\s]*')
+- return compile(pattern).match
+-
+-
+-def exec_handlers(uzbl, handlers, key, arg):
+- '''Execute the on_set handlers that matched the key.'''
+-
+- for handler in handlers:
+- if callable(handler):
+- handler(key, arg)
+-
+- else:
+- uzbl.send(uzbl.cmd_expand(handler, [key, arg]))
+-
+-
+-def check_for_handlers(uzbl, key, arg):
+- '''Check for handlers for the current key.'''
+-
+- for (matcher, handlers) in uzbl.on_sets.values():
+- if matcher(key):
+- exec_handlers(uzbl, handlers, key, arg)
+-
+-
+-def on_set(uzbl, glob, handler, prepend=True):
+- '''Add a new handler for a config key change.
+-
+- Structure of the `uzbl.on_sets` dict:
+- { glob : ( glob matcher function, handlers list ), .. }
+- '''
+-
+- assert valid_glob(glob)
+-
+- while '**' in glob:
+- glob = glob.replace('**', '*')
+-
+- if callable(handler):
+- orig_handler = handler
+- if prepend:
+- handler = partial(handler, uzbl)
+-
+- else:
+- orig_handler = handler = unicode(handler)
+-
+- if glob in uzbl.on_sets:
+- (matcher, handlers) = uzbl.on_sets[glob]
+- handlers.append(handler)
+-
+- else:
+- matcher = make_matcher(glob)
+- uzbl.on_sets[glob] = (matcher, [handler,])
+-
+- uzbl.logger.info('on set %r call %r' % (glob, orig_handler))
+-
+-
+-def parse_on_set(uzbl, args):
+- '''Parse `ON_SET <glob> <command>` event then pass arguments to the
+- `on_set(..)` function.'''
+-
+- (glob, command) = (args.split(' ', 1) + [None,])[:2]
+- assert glob and command and valid_glob(glob)
+- on_set(uzbl, glob, command)
+-
+-
+-# plugins init hook
+-def init(uzbl):
+- require('config')
+- require('cmd_expand')
+-
+- export_dict(uzbl, {
+- 'on_sets': {},
+- 'on_set': on_set,
+- })
+-
+- connect_dict(uzbl, {
+- 'ON_SET': parse_on_set,
+- 'CONFIG_CHANGED': check_for_handlers,
+- })
+-
+-# plugins cleanup hook
+-def cleanup(uzbl):
+- for (matcher, handlers) in uzbl.on_sets.values():
+- del handlers[:]
+-
+- uzbl.on_sets.clear()
+diff --git a/examples/data/plugins/progress_bar.py b/examples/data/plugins/progress_bar.py
+deleted file mode 100644
+index b2edffc..0000000
+--- a/examples/data/plugins/progress_bar.py
++++ /dev/null
+@@ -1,93 +0,0 @@
+-UPDATES = 0
+-
+-def update_progress(uzbl, progress=None):
+- '''Updates the progress.output variable on LOAD_PROGRESS update.
+-
+- The current substitution options are:
+- %d = done char * done
+- %p = pending char * remaining
+- %c = percent done
+- %i = int done
+- %s = -\|/ spinner
+- %t = percent pending
+- %o = int pending
+- %r = sprites
+-
+- Default configuration options:
+- progress.format = [%d>%p]%c
+- progress.width = 8
+- progress.done = =
+- progress.pending =
+- progress.spinner = -\|/
+- progress.sprites = loading
+- '''
+-
+- global UPDATES
+-
+- if progress is None:
+- UPDATES = 0
+- progress = 100
+-
+- else:
+- UPDATES += 1
+- progress = int(progress)
+-
+- # Get progress config vars.
+- format = uzbl.config.get('progress.format', '[%d>%p]%c')
+- width = int(uzbl.config.get('progress.width', 8))
+- done_symbol = uzbl.config.get('progress.done', '=')
+- pend = uzbl.config.get('progress.pending', None)
+- pending_symbol = pend if pend else ' '
+-
+- # Inflate the done and pending bars to stop the progress bar
+- # jumping around.
+- if '%c' in format or '%i' in format:
+- count = format.count('%c') + format.count('%i')
+- width += (3-len(str(progress))) * count
+-
+- if '%t' in format or '%o' in format:
+- count = format.count('%t') + format.count('%o')
+- width += (3-len(str(100-progress))) * count
+-
+- done = int(((progress/100.0)*width)+0.5)
+- pending = width - done
+-
+- if '%d' in format:
+- format = format.replace('%d', done_symbol * done)
+-
+- if '%p' in format:
+- format = format.replace('%p', pending_symbol * pending)
+-
+- if '%c' in format:
+- format = format.replace('%c', '%d%%' % progress)
+-
+- if '%i' in format:
+- format = format.replace('%i', '%d' % progress)
+-
+- if '%t' in format:
+- format = format.replace('%t', '%d%%' % (100-progress))
+-
+- if '%o' in format:
+- format = format.replace('%o', '%d' % (100-progress))
+-
+- if '%s' in format:
+- spinner = uzbl.config.get('progress.spinner', '-\\|/')
+- index = 0 if progress == 100 else UPDATES % len(spinner)
+- spin = '\\\\' if spinner[index] == '\\' else spinner[index]
+- format = format.replace('%s', spin)
+-
+- if '%r' in format:
+- sprites = uzbl.config.get('progress.sprites', 'loading')
+- index = int(((progress/100.0)*len(sprites))+0.5)-1
+- sprite = '\\\\' if sprites[index] == '\\' else sprites[index]
+- format = format.replace('%r', sprite)
+-
+- if uzbl.config.get('progress.output', None) != format:
+- uzbl.config['progress.output'] = format
+-
+-# plugin init hook
+-def init(uzbl):
+- connect_dict(uzbl, {
+- 'LOAD_COMMIT': lambda uzbl, uri: update_progress(uzbl),
+- 'LOAD_PROGRESS': update_progress,
+- })
+diff --git a/examples/data/scripts/auth.py b/examples/data/scripts/auth.py
+index 49fa41e..dbf58dc 100755
+--- a/examples/data/scripts/auth.py
++++ b/examples/data/scripts/auth.py
+@@ -1,5 +1,6 @@
+ #!/usr/bin/env python
+
++import os
+ import gtk
+ import sys
+
+@@ -41,13 +42,20 @@ def getText(authInfo, authHost, authRealm):
+ dialog.show_all()
+ rv = dialog.run()
+
+- output = login.get_text() + "\n" + password.get_text()
++ output = {
++ 'username': login.get_text(),
++ 'password': password.get_text()
++ }
+ dialog.destroy()
+ return rv, output
+
+ if __name__ == '__main__':
+- rv, output = getText(sys.argv[1], sys.argv[2], sys.argv[3])
++ fifo = open(os.environ.get('UZBL_FIFO'), 'w')
++ me, info, host, realm = sys.argv
++ rv, output = getText(info, host, realm)
+ if (rv == gtk.RESPONSE_OK):
+- print output;
++ print >> fifo, 'auth "%s" "%s" "%s"' % (
++ info, output['username'], output['password']
++ )
+ else:
+ exit(1)
+diff --git a/examples/data/scripts/follow.js b/examples/data/scripts/follow.js
+index 83bbf55..0afeec3 100644
+--- a/examples/data/scripts/follow.js
++++ b/examples/data/scripts/follow.js
+@@ -12,6 +12,7 @@
+
+ // Globals
+ uzbldivid = 'uzbl_link_hints';
++var uzbl = uzbl || {};
+
+ uzbl.follow = function() {
+ // Export
+diff --git a/examples/data/scripts/formfiller.js b/examples/data/scripts/formfiller.js
+index 06db648..9c56f7b 100644
+--- a/examples/data/scripts/formfiller.js
++++ b/examples/data/scripts/formfiller.js
+@@ -1,3 +1,5 @@
++var uzbl = uzbl || {};
++
+ uzbl.formfiller = {
+
+ // this is pointlessly duplicated in uzbl.follow
+diff --git a/examples/data/scripts/history.sh b/examples/data/scripts/history.sh
+index 0709b5e..2d96a07 100755
+--- a/examples/data/scripts/history.sh
++++ b/examples/data/scripts/history.sh
+@@ -1,5 +1,7 @@
+ #!/bin/sh
+
++[ -n "$UZBL_PRIVATE" ] && exit 0
++
+ . "$UZBL_UTIL_DIR/uzbl-dir.sh"
+
+ >> "$UZBL_HISTORY_FILE" || exit 1
+diff --git a/examples/data/scripts/scheme.py b/examples/data/scripts/scheme.py
+index 4b0b7ca..c652478 100755
+--- a/examples/data/scripts/scheme.py
++++ b/examples/data/scripts/scheme.py
+@@ -1,6 +1,11 @@
+ #!/usr/bin/env python
+
+-import os, subprocess, sys, urlparse
++import os, subprocess, sys
++
++try:
++ import urllib.parse as urlparse
++except ImportError:
++ import urlparse
+
+ def detach_open(cmd):
+ # Thanks to the vast knowledge of Laurence Withers (lwithers) and this message:
+@@ -10,7 +15,7 @@ def detach_open(cmd):
+ for i in range(3): os.dup2(null,i)
+ os.close(null)
+ subprocess.Popen(cmd)
+- print 'USED'
++ print('USED')
+
+ if __name__ == '__main__':
+ uri = sys.argv[1]
+diff --git a/misc/env.sh b/misc/env.sh
+index f815c44..d5f0db8 100755
+--- a/misc/env.sh
++++ b/misc/env.sh
+@@ -28,3 +28,11 @@ export XDG_CONFIG_HOME
+ # Needed to run uzbl-browser etc from here.
+ PATH="$(pwd)/sandbox/usr/local/bin:$PATH"
+ export PATH
++
++PYTHONLIB=$(python3 -c 'from distutils.sysconfig import get_python_lib; print(get_python_lib(prefix="/usr/local"))')
++
++UZBL_PLUGIN_PATH="$(pwd)/sandbox/$PYTHONLIB/uzbl/plugins"
++export UZBL_PLUGIN_PATH
++
++PYTHONPATH="$(pwd)/sandbox/$PYTHONLIB/"
++export PYTHONPATH
+diff --git a/setup.py b/setup.py
+new file mode 100644
+index 0000000..5dd6b59
+--- /dev/null
++++ b/setup.py
+@@ -0,0 +1,11 @@
++from distutils.core import setup
++
++setup(name='uzbl',
++ version='201100808',
++ description='Uzbl event daemon',
++ url='http://uzbl.org',
++ packages=['uzbl', 'uzbl.plugins'],
++ scripts=[
++ 'bin/uzbl-event-manager',
++ ],
++ )
+diff --git a/src/callbacks.c b/src/callbacks.c
+index eee9f69..370f679 100644
+--- a/src/callbacks.c
++++ b/src/callbacks.c
+@@ -10,6 +10,8 @@
+ #include "type.h"
+ #include "variables.h"
+
++#include <gdk/gdk.h>
++
+ void
+ link_hover_cb (WebKitWebView *page, const gchar *title, const gchar *link, gpointer data) {
+ (void) page; (void) title; (void) data;
+@@ -147,6 +149,21 @@ key_release_cb (GtkWidget* window, GdkEventKey* event) {
+ return uzbl.behave.forward_keys ? FALSE : TRUE;
+ }
+
++gint
++get_click_context() {
++ WebKitHitTestResult *ht;
++ guint context;
++
++ if(!uzbl.state.last_button)
++ return -1;
++
++ ht = webkit_web_view_get_hit_test_result (uzbl.gui.web_view, uzbl.state.last_button);
++ g_object_get (ht, "context", &context, NULL);
++ g_object_unref (ht);
++
++ return (gint)context;
++}
++
+ gboolean
+ button_press_cb (GtkWidget* window, GdkEventButton* event) {
+ (void) window;
+@@ -233,22 +250,9 @@ button_release_cb (GtkWidget* window, GdkEventButton* event) {
+ }
+
+ gboolean
+-motion_notify_cb(GtkWidget* window, GdkEventMotion* event, gpointer user_data) {
+- (void) window;
+- (void) event;
+- (void) user_data;
+-
+- send_event (PTR_MOVE, NULL,
+- TYPE_FLOAT, event->x,
+- TYPE_FLOAT, event->y,
+- TYPE_INT, event->state,
+- NULL);
+-
+- return FALSE;
+-}
+-
+-gboolean
+-navigation_decision_cb (WebKitWebView *web_view, WebKitWebFrame *frame, WebKitNetworkRequest *request, WebKitWebNavigationAction *navigation_action, WebKitWebPolicyDecision *policy_decision, gpointer user_data) {
++navigation_decision_cb (WebKitWebView *web_view, WebKitWebFrame *frame,
++ WebKitNetworkRequest *request, WebKitWebNavigationAction *navigation_action,
++ WebKitWebPolicyDecision *policy_decision, gpointer user_data) {
+ (void) web_view;
+ (void) frame;
+ (void) navigation_action;
+@@ -288,39 +292,16 @@ navigation_decision_cb (WebKitWebView *web_view, WebKitWebFrame *frame, WebKitNe
+ return TRUE;
+ }
+
+-gboolean
+-new_window_cb (WebKitWebView *web_view, WebKitWebFrame *frame,
+- WebKitNetworkRequest *request, WebKitWebNavigationAction *navigation_action,
+- WebKitWebPolicyDecision *policy_decision, gpointer user_data) {
+- (void) web_view;
+- (void) frame;
+- (void) navigation_action;
+- (void) policy_decision;
+- (void) user_data;
+-
+- if (uzbl.state.verbose)
+- printf ("New window requested -> %s \n", webkit_network_request_get_uri (request));
+-
+- /* This event function causes troubles with `target="_blank"` anchors.
+- * Either we:
+- * 1. Comment it out and target blank links are ignored.
+- * 2. Uncomment it and two windows are opened when you click on target
+- * blank links.
+- *
+- * This problem is caused by create_web_view_cb also being called whenever
+- * this callback is triggered thus resulting in the doubled events.
+- *
+- * We are leaving this uncommented as we would rather links open twice
+- * than not at all.
+- */
+- send_event (NEW_WINDOW, NULL, TYPE_STR, webkit_network_request_get_uri (request), NULL);
+-
+- webkit_web_policy_decision_ignore (policy_decision);
+- return TRUE;
++void
++close_web_view_cb(WebKitWebView *webview, gpointer user_data) {
++ (void) webview; (void) user_data;
++ send_event (CLOSE_WINDOW, NULL, NULL);
+ }
+
+ gboolean
+-mime_policy_cb(WebKitWebView *web_view, WebKitWebFrame *frame, WebKitNetworkRequest *request, gchar *mime_type, WebKitWebPolicyDecision *policy_decision, gpointer user_data) {
++mime_policy_cb (WebKitWebView *web_view, WebKitWebFrame *frame,
++ WebKitNetworkRequest *request, gchar *mime_type,
++ WebKitWebPolicyDecision *policy_decision, gpointer user_data) {
+ (void) frame;
+ (void) request;
+ (void) user_data;
+@@ -345,11 +326,17 @@ request_starting_cb(WebKitWebView *web_view, WebKitWebFrame *frame, WebKitWebRes
+ (void) response;
+ (void) user_data;
+
+- const gchar* uri = webkit_network_request_get_uri (request);
++ const gchar *uri = webkit_network_request_get_uri (request);
++ SoupMessage *message = webkit_network_request_get_message (request);
++
++ if (message) {
++ SoupURI *soup_uri = soup_uri_new (uri);
++ soup_message_set_first_party (message, soup_uri);
++ }
+
+ if (uzbl.state.verbose)
+ printf("Request starting -> %s\n", uri);
+- send_event (REQUEST_STARTING, NULL, TYPE_STR, webkit_network_request_get_uri(request), NULL);
++ send_event (REQUEST_STARTING, NULL, TYPE_STR, uri, NULL);
+
+ if (uzbl.behave.request_handler) {
+ GString *result = g_string_new ("");
+@@ -373,17 +360,16 @@ request_starting_cb(WebKitWebView *web_view, WebKitWebFrame *frame, WebKitWebRes
+ }
+
+ void
+-create_web_view_js_cb (WebKitWebView* web_view, GParamSpec param_spec) {
++create_web_view_got_uri_cb (WebKitWebView* web_view, GParamSpec param_spec) {
+ (void) web_view;
+ (void) param_spec;
+
+ webkit_web_view_stop_loading(web_view);
++
+ const gchar* uri = webkit_web_view_get_uri(web_view);
+
+- if (strncmp(uri, "javascript:", strlen("javascript:")) == 0) {
++ if (strncmp(uri, "javascript:", strlen("javascript:")) == 0)
+ eval_js(uzbl.gui.web_view, (gchar*) uri + strlen("javascript:"), NULL, "javascript:");
+- gtk_widget_destroy(GTK_WIDGET(web_view));
+- }
+ else
+ send_event(NEW_WINDOW, NULL, TYPE_STR, uri, NULL);
+ }
+@@ -394,14 +380,29 @@ create_web_view_cb (WebKitWebView *web_view, WebKitWebFrame *frame, gpointer us
+ (void) frame;
+ (void) user_data;
+
+- if (uzbl.state.verbose)
+- printf("New web view -> javascript link...\n");
+-
+- WebKitWebView* new_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
++ // unfortunately we don't know the URL at this point; all webkit-gtk will
++ // tell us is that we're opening a new window.
++ //
++ // (we can't use the new-window-policy-decision-requested event; it doesn't
++ // fire when Javascript requests a new window with window.open().)
++ //
++ // so, we have to create a temporary web view and allow it to load. webkit
++ // segfaults if we try to destroy it or mark it for garbage collection in
++ // create_web_view_got_uri_cb, so we might as well keep it around and reuse
++ // it.
++
++ if(!uzbl.state._tmp_web_view) {
++ uzbl.state._tmp_web_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
++
++ g_object_connect (uzbl.state._tmp_web_view, "signal::notify::uri",
++ G_CALLBACK(create_web_view_got_uri_cb), NULL, NULL);
++
++ // we're taking ownership of this WebView (sinking its floating reference
++ // since it will never be added to a display widget).
++ g_object_ref_sink(uzbl.state._tmp_web_view);
++ }
+
+- g_object_connect (new_view, "signal::notify::uri",
+- G_CALLBACK(create_web_view_js_cb), NULL, NULL);
+- return new_view;
++ return uzbl.state._tmp_web_view;
+ }
+
+ void
+@@ -464,7 +465,21 @@ download_cb(WebKitWebView *web_view, WebKitDownload *download, gpointer user_dat
+
+ /* get a reasonable suggestion for a filename */
+ const gchar *suggested_filename;
++#ifdef USE_WEBKIT2
++ WebKitURIResponse *response;
++ g_object_get(download, "network-response", &response, NULL);
++#if WEBKIT_CHECK_VERSION (1, 9, 90)
++ g_object_get(response, "suggested-filename", &suggested_filename, NULL);
++#else
++ suggested_filename = webkit_uri_response_get_suggested_filename(respose);
++#endif
++#elif WEBKIT_CHECK_VERSION (1, 9, 6)
++ WebKitNetworkResponse *response;
++ g_object_get(download, "network-response", &response, NULL);
++ g_object_get(response, "suggested-filename", &suggested_filename, NULL);
++#else
+ g_object_get(download, "suggested-filename", &suggested_filename, NULL);
++#endif
+
+ /* get the mimetype of the download */
+ const gchar *content_type = NULL;
+@@ -582,90 +597,107 @@ run_menu_command(GtkWidget *menu, MenuItem *mi) {
+ (void) menu;
+
+ if (mi->context & WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE) {
+- gchar* uri;
+- g_object_get(mi->hittest, "image-uri", &uri, NULL);
+- gchar* cmd = g_strdup_printf("%s %s", mi->cmd, uri);
++ gchar* cmd = g_strdup_printf("%s %s", mi->cmd, mi->argument);
+
+ parse_cmd_line(cmd, NULL);
+
+ g_free(cmd);
+- g_free(uri);
+- g_object_unref(mi->hittest);
++ g_free(mi->argument);
+ }
+ else {
+ parse_cmd_line(mi->cmd, NULL);
+ }
+ }
+
++gboolean
++populate_context_menu (GtkWidget *default_menu, WebKitHitTestResult *hit_test_result, gint context) {
++ guint i;
++
++ /* find the user-defined menu items that are approprate for whatever was
++ * clicked and append them to the default context menu. */
++ for(i = 0; i < uzbl.gui.menu_items->len; i++) {
++ MenuItem *mi = g_ptr_array_index(uzbl.gui.menu_items, i);
++ GtkWidget *item;
++
++ gboolean contexts_match = (context & mi->context);
++
++ if(!contexts_match) {
++ continue;
++ }
++
++ if (mi->context & WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE) {
++ g_object_get(hit_test_result, "image-uri", &(mi->argument), NULL);
++ }
++
++ if(mi->issep) {
++ item = gtk_separator_menu_item_new();
++ } else {
++ item = gtk_menu_item_new_with_label(mi->name);
++ g_signal_connect(item, "activate",
++ G_CALLBACK(run_menu_command), mi);
++ }
++
++ gtk_menu_shell_append(GTK_MENU_SHELL(default_menu), item);
++ gtk_widget_show(item);
++ }
++
++ return FALSE;
++}
++
++#if WEBKIT_CHECK_VERSION (1, 9, 0)
++gboolean
++context_menu_cb (WebKitWebView *v, GtkWidget *default_menu, WebKitHitTestResult *hit_test_result, gboolean triggered_with_keyboard, gpointer user_data) {
++ (void) v; (void) triggered_with_keyboard; (void) user_data;
++ gint context;
++
++ if(!uzbl.gui.menu_items)
++ return FALSE;
++
++ /* check context */
++ if((context = get_click_context()) == -1)
++ return FALSE;
+
++ /* display the default menu with our modifications. */
++ return populate_context_menu(default_menu, hit_test_result, context);
++}
++#else
+ void
+ populate_popup_cb(WebKitWebView *v, GtkMenu *m, void *c) {
+ (void) c;
+- GUI *g = &uzbl.gui;
+- GtkWidget *item;
+- MenuItem *mi;
+- guint i=0;
+- gint context, hit=0;
++ gint context;
+
+- if(!g->menu_items)
++ if(!uzbl.gui.menu_items)
+ return;
+
+ /* check context */
+ if((context = get_click_context()) == -1)
+ return;
+
+- for(i=0; i < uzbl.gui.menu_items->len; i++) {
+- hit = 0;
+- mi = g_ptr_array_index(uzbl.gui.menu_items, i);
++ WebKitHitTestResult *hit_test_result;
++ GdkEventButton ev;
++ gint x, y;
++#if GTK_CHECK_VERSION (3, 0, 0)
++ gdk_window_get_device_position (gtk_widget_get_window(GTK_WIDGET(v)),
++ gdk_device_manager_get_client_pointer (
++ gdk_display_get_device_manager (
++ gtk_widget_get_display (GTK_WIDGET (v)))),
++ &x, &y, NULL);
++#else
++ gdk_window_get_pointer(gtk_widget_get_window(GTK_WIDGET(v)), &x, &y, NULL);
++#endif
++ ev.x = x;
++ ev.y = y;
++ hit_test_result = webkit_web_view_get_hit_test_result(v, &ev);
+
+- if (mi->context & WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE) {
+- GdkEventButton ev;
+- gint x, y;
+- gdk_window_get_pointer(gtk_widget_get_window(GTK_WIDGET(v)), &x, &y, NULL);
+- ev.x = x;
+- ev.y = y;
+- mi->hittest = webkit_web_view_get_hit_test_result(v, &ev);
+- }
++ populate_context_menu(m, hit_test_result, context);
+
+- if((mi->context > WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT) &&
+- (context & mi->context)) {
+- if(mi->issep) {
+- item = gtk_separator_menu_item_new();
+- gtk_menu_shell_append(GTK_MENU_SHELL(m), item);
+- gtk_widget_show(item);
+- }
+- else {
+- item = gtk_menu_item_new_with_label(mi->name);
+- g_signal_connect(item, "activate",
+- G_CALLBACK(run_menu_command), mi);
+- gtk_menu_shell_append(GTK_MENU_SHELL(m), item);
+- gtk_widget_show(item);
+- }
+- hit++;
+- }
+-
+- if((mi->context == WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT) &&
+- (context <= WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT) &&
+- !hit) {
+- if(mi->issep) {
+- item = gtk_separator_menu_item_new();
+- gtk_menu_shell_append(GTK_MENU_SHELL(m), item);
+- gtk_widget_show(item);
+- }
+- else {
+- item = gtk_menu_item_new_with_label(mi->name);
+- g_signal_connect(item, "activate",
+- G_CALLBACK(run_menu_command), mi);
+- gtk_menu_shell_append(GTK_MENU_SHELL(m), item);
+- gtk_widget_show(item);
+- }
+- }
+- }
++ g_object_unref(hit_test_result);
+ }
++#endif
+
+ void
+ window_object_cleared_cb(WebKitWebView *webview, WebKitWebFrame *frame,
+- JSGlobalContextRef *context, JSObjectRef *object) {
++ JSGlobalContextRef *context, JSObjectRef *object) {
+ (void) frame; (void) context; (void) object;
+ #if WEBKIT_CHECK_VERSION (1, 3, 13)
+ // Take this opportunity to set some callbacks on the DOM
+diff --git a/src/callbacks.h b/src/callbacks.h
+index 6a10205..56bf612 100644
+--- a/src/callbacks.h
++++ b/src/callbacks.h
+@@ -31,19 +31,11 @@ gboolean
+ key_release_cb (GtkWidget* window, GdkEventKey* event);
+
+ gboolean
+-motion_notify_cb(GtkWidget* window, GdkEventMotion* event, gpointer user_data);
+-
+-gboolean
+ navigation_decision_cb (WebKitWebView *web_view, WebKitWebFrame *frame,
+ WebKitNetworkRequest *request, WebKitWebNavigationAction *navigation_action,
+ WebKitWebPolicyDecision *policy_decision, gpointer user_data);
+
+ gboolean
+-new_window_cb (WebKitWebView *web_view, WebKitWebFrame *frame,
+- WebKitNetworkRequest *request, WebKitWebNavigationAction *navigation_action,
+- WebKitWebPolicyDecision *policy_decision, gpointer user_data);
+-
+-gboolean
+ mime_policy_cb(WebKitWebView *web_view, WebKitWebFrame *frame, WebKitNetworkRequest *request,
+ gchar *mime_type, WebKitWebPolicyDecision *policy_decision, gpointer user_data);
+
+@@ -57,8 +49,13 @@ create_web_view_cb (WebKitWebView *web_view, WebKitWebFrame *frame, gpointer us
+ gboolean
+ download_cb (WebKitWebView *web_view, WebKitDownload *download, gpointer user_data);
+
++#if WEBKIT_CHECK_VERSION (1, 9, 0)
++gboolean
++context_menu_cb (WebKitWebView *web_view, GtkWidget *default_menu, WebKitHitTestResult *hit_test_result, gboolean triggered_with_keyboard, gpointer user_data);
++#else
+ void
+ populate_popup_cb(WebKitWebView *v, GtkMenu *m, void *c);
++#endif
+
+ gboolean
+ button_press_cb (GtkWidget* window, GdkEventButton* event);
+@@ -76,8 +73,11 @@ gboolean
+ scroll_horiz_cb(GtkAdjustment *adjust, void *w);
+
+ void
++close_web_view_cb(WebKitWebView *webview, gpointer user_data);
++
++void
+ window_object_cleared_cb(WebKitWebView *webview, WebKitWebFrame *frame,
+- JSGlobalContextRef *context, JSObjectRef *object);
++ JSGlobalContextRef *context, JSObjectRef *object);
+
+ #if WEBKIT_CHECK_VERSION (1, 3, 13)
+ void
+diff --git a/src/commands.c b/src/commands.c
+index b3546a9..6769189 100644
+--- a/src/commands.c
++++ b/src/commands.c
+@@ -6,6 +6,7 @@
+ #include "callbacks.h"
+ #include "variables.h"
+ #include "type.h"
++#include "soup.h"
+
+ /* -- command to callback/function map for things we cannot attach to any signals */
+ CommandInfo cmdlist[] =
+@@ -54,12 +55,34 @@ CommandInfo cmdlist[] =
+ { "menu_image_remove", menu_remove_image, TRUE },
+ { "menu_editable_remove", menu_remove_edit, TRUE },
+ { "hardcopy", hardcopy, TRUE },
++#ifndef USE_WEBKIT2
++#if WEBKIT_CHECK_VERSION (1, 9, 6)
++ { "snapshot", snapshot, TRUE },
++#endif
++#endif
++#ifdef USE_WEBKIT2
++#if WEBKIT_CHECK_VERSION (1, 9, 90)
++ { "load", load, TRUE },
++ { "save", save, TRUE },
++#endif
++#endif
++ { "remove_all_db", remove_all_db, 0 },
++#if WEBKIT_CHECK_VERSION (1, 3, 8)
++ { "plugin_refresh", plugin_refresh, TRUE },
++ { "plugin_toggle", plugin_toggle, TRUE },
++#endif
+ { "include", include, TRUE },
++ /* Deprecated */
+ { "show_inspector", show_inspector, 0 },
++ { "inspector", inspector, TRUE },
++#if WEBKIT_CHECK_VERSION (1, 5, 1)
++ { "spell_checker", spell_checker, TRUE },
++#endif
+ { "add_cookie", add_cookie, 0 },
+ { "delete_cookie", delete_cookie, 0 },
+ { "clear_cookies", clear_cookies, 0 },
+- { "download", download, 0 }
++ { "download", download, 0 },
++ { "auth", auth, 0 }
+ };
+
+ void
+@@ -190,7 +213,11 @@ toggle_var(WebKitWebView *page, GArray *argv, GString *result) {
+ uzbl_cmdprop *c = get_var_c(var_name);
+
+ if(!c) {
+- set_var_value(var_name, argv_idx(argv, 1));
++ if (argv->len > 1) {
++ set_var_value(var_name, argv_idx(argv, 1));
++ } else {
++ set_var_value(var_name, "1");
++ }
+ return;
+ }
+
+@@ -230,18 +257,18 @@ toggle_var(WebKitWebView *page, GArray *argv, GString *result) {
+ if(argv->len >= 3) {
+ guint i = 2;
+
+- int first = strtoul(argv_idx(argv, 1), NULL, 10);
++ int first = strtol(argv_idx(argv, 1), NULL, 10);
+ int this = first;
+
+ const gchar *next_s = argv_idx(argv, 2);
+
+ while(next_s && this != current) {
+- this = strtoul(next_s, NULL, 10);
++ this = strtol(next_s, NULL, 10);
+ next_s = argv_idx(argv, ++i);
+ }
+
+ if(next_s)
+- next = strtoul(next_s, NULL, 10);
++ next = strtol(next_s, NULL, 10);
+ else
+ next = first;
+ } else
+@@ -250,6 +277,34 @@ toggle_var(WebKitWebView *page, GArray *argv, GString *result) {
+ set_var_value_int_c(c, next);
+ break;
+ }
++ case TYPE_ULL:
++ {
++ unsigned long long current = get_var_value_int_c(c);
++ unsigned long long next;
++
++ if(argv->len >= 3) {
++ guint i = 2;
++
++ unsigned long long first = strtoull(argv_idx(argv, 1), NULL, 10);
++ unsigned long long this = first;
++
++ const gchar *next_s = argv_idx(argv, 2);
++
++ while(next_s && this != current) {
++ this = strtoull(next_s, NULL, 10);
++ next_s = argv_idx(argv, ++i);
++ }
++
++ if(next_s)
++ next = strtoull(next_s, NULL, 10);
++ else
++ next = first;
++ } else
++ next = !current;
++
++ set_var_value_ull_c(c, next);
++ break;
++ }
+ case TYPE_FLOAT:
+ {
+ float current = get_var_value_float_c(c);
+@@ -325,6 +380,117 @@ hardcopy(WebKitWebView *page, GArray *argv, GString *result) {
+ webkit_web_frame_print(webkit_web_view_get_main_frame(page));
+ }
+
++#ifndef USE_WEBKIT2
++#if WEBKIT_CHECK_VERSION (1, 9, 6)
++void
++snapshot(WebKitWebView *page, GArray *argv, GString *result) {
++ (void) result;
++ cairo_surface_t* surface;
++
++ surface = webkit_web_view_get_snapshot(page);
++
++ cairo_surface_write_to_png(surface, argv_idx(argv, 0));
++
++ cairo_surface_destroy(surface);
++}
++#endif
++#endif
++
++#ifdef USE_WEBKIT2
++#if WEBKIT_CHECK_VERSION (1, 9, 90)
++void
++load(WebKitWebView *page, GArray *argv, GString *result) {
++ (void) result;
++
++ guint sz = argv->len;
++
++ const gchar *content = sz > 0 ? argv_idx(argv, 0) : NULL;
++ const gchar *content_uri = sz > 2 ? argv_idx(argv, 1) : NULL;
++ const gchar *base_uri = sz > 2 ? argv_idx(argv, 2) : NULL;
++
++ webkit_web_view_load_alternate_html(page, content, content_uri, base_uri);
++}
++
++void
++save(WebKitWebView *page, GArray *argv, GString *result) {
++ (void) result;
++ guint sz = argv->len;
++
++ const gchar *mode_str = sz > 0 ? argv_idx(argv, 0) : NULL;
++
++ WebKitSaveMode mode = WEBKIT_SAVE_MODE_MHTML;
++
++ if (!mode) {
++ mode = WEBKIT_SAVE_MODE_MHTML;
++ } else if (!strcmp("mhtml", mode_str)) {
++ mode = WEBKIT_SAVE_MODE_MHTML;
++ }
++
++ if (sz > 1) {
++ const gchar *path = argv_idx(argv, 1);
++ GFile *gfile = g_file_new_for_path(path);
++
++ webkit_web_view_save_to_file(page, gfile, mode, NULL, NULL, NULL);
++ /* TODO: Don't ignore the error */
++ webkit_web_view_save_to_file_finish(page, NULL, NULL);
++ } else {
++ webkit_web_view_save(page, mode, NULL, NULL, NULL);
++ /* TODO: Don't ignore the error */
++ webkit_web_view_save_finish(page, NULL, NULL);
++ }
++}
++#endif
++#endif
++
++void
++remove_all_db(WebKitWebView *page, GArray *argv, GString *result) {
++ (void) page; (void) argv; (void) result;
++
++ webkit_remove_all_web_databases ();
++}
++
++#if WEBKIT_CHECK_VERSION (1, 3, 8)
++void
++plugin_refresh(WebKitWebView *page, GArray *argv, GString *result) {
++ (void) page; (void) argv; (void) result;
++
++ WebKitWebPluginDatabase *db = webkit_get_web_plugin_database ();
++ webkit_web_plugin_database_refresh (db);
++}
++
++static void
++plugin_toggle_one(WebKitWebPlugin *plugin, const gchar *name) {
++ const gchar *plugin_name = webkit_web_plugin_get_name (plugin);
++
++ if (!name || !g_strcmp0 (name, plugin_name)) {
++ gboolean enabled = webkit_web_plugin_get_enabled (plugin);
++
++ webkit_web_plugin_set_enabled (plugin, !enabled);
++ }
++}
++
++void
++plugin_toggle(WebKitWebView *page, GArray *argv, GString *result) {
++ (void) page; (void) result;
++
++ WebKitWebPluginDatabase *db = webkit_get_web_plugin_database ();
++ GSList *plugins = webkit_web_plugin_database_get_plugins (db);
++
++ if (argv->len == 0) {
++ g_slist_foreach (plugins, (GFunc)plugin_toggle_one, NULL);
++ } else {
++ guint i;
++ for (i = 0; i < argv->len; ++i) {
++ const gchar *plugin_name = argv_idx (argv, i);
++
++ g_slist_foreach (plugins, (GFunc)plugin_toggle_one, &plugin_name);
++ }
++ }
++
++ webkit_web_plugin_database_plugins_list_free (plugins);
++}
++#endif
++
+ void
+ include(WebKitWebView *page, GArray *argv, GString *result) {
+ (void) page; (void) result;
+@@ -348,6 +514,103 @@ show_inspector(WebKitWebView *page, GArray *argv, GString *result) {
+ }
+
+ void
++inspector(WebKitWebView *page, GArray *argv, GString *result) {
++ (void) page; (void) result;
++
++ if (argv->len < 1) {
++ return;
++ }
++
++ const gchar* command = argv_idx (argv, 0);
++
++ if (!g_strcmp0 (command, "show")) {
++ webkit_web_inspector_show (uzbl.gui.inspector);
++ } else if (!g_strcmp0 (command, "close")) {
++ webkit_web_inspector_close (uzbl.gui.inspector);
++ } else if (!g_strcmp0 (command, "coord")) {
++ if (argv->len < 3) {
++ return;
++ }
++
++ gdouble x = strtod (argv_idx (argv, 1), NULL);
++ gdouble y = strtod (argv_idx (argv, 2), NULL);
++
++ /* Let's not tempt the dragons. */
++ if (errno == ERANGE) {
++ return;
++ }
++
++ webkit_web_inspector_inspect_coordinates (uzbl.gui.inspector, x, y);
++#if WEBKIT_CHECK_VERSION (1, 3, 17)
++ } else if (!g_strcmp0 (command, "node")) {
++ /* TODO: Implement */
++#endif
++ }
++}
++
++#if WEBKIT_CHECK_VERSION (1, 5, 1)
++void
++spell_checker(WebKitWebView *page, GArray *argv, GString *result) {
++ (void) page;
++
++ if (argv->len < 1) {
++ return;
++ }
++
++ GObject *obj = webkit_get_text_checker ();
++
++ if (!obj) {
++ return;
++ }
++ if (!WEBKIT_IS_SPELL_CHECKER (obj)) {
++ return;
++ }
++
++ WebKitSpellChecker *checker = WEBKIT_SPELL_CHECKER (obj);
++
++ const gchar* command = argv_idx (argv, 0);
++
++ if (!g_strcmp0 (command, "ignore")) {
++ if (argv->len < 2) {
++ return;
++ }
++
++ guint i;
++ for (i = 1; i < argv->len; ++i) {
++ const gchar *word = argv_idx (argv, i);
++
++ webkit_spell_checker_ignore_word (checker, word);
++ }
++ } else if (!g_strcmp0 (command, "learn")) {
++ if (argv->len < 2) {
++ return;
++ }
++
++ guint i;
++ for (i = 1; i < argv->len; ++i) {
++ const gchar *word = argv_idx (argv, i);
++
++ webkit_spell_checker_learn_word (checker, word);
++ }
++ } else if (!g_strcmp0 (command, "autocorrect")) {
++ if (argv->len != 2) {
++ return;
++ }
++
++ gchar *word = argv_idx (argv, 1);
++
++ char *new_word = webkit_spell_checker_get_autocorrect_suggestions_for_misspelled_word (checker, word);
++
++ g_string_assign (result, new_word);
++
++ free (new_word);
++ } else if (!g_strcmp0 (command, "guesses")) {
++ /* TODO Implement */
++ }
++}
++#endif
++
++void
+ add_cookie(WebKitWebView *page, GArray *argv, GString *result) {
+ (void) page; (void) result;
+ gchar *host, *path, *name, *value, *scheme;
+@@ -583,3 +846,18 @@ act_dump_config_as_events(WebKitWebView *web_view, GArray *argv, GString *result
+ (void)web_view; (void) argv; (void)result;
+ dump_config_as_events();
+ }
++
++void
++auth(WebKitWebView *page, GArray *argv, GString *result) {
++ (void) page; (void) result;
++ gchar *info, *username, *password;
++
++ if(argv->len != 3)
++ return;
++
++ info = argv_idx (argv, 0);
++ username = argv_idx (argv, 1);
++ password = argv_idx (argv, 2);
++
++ authenticate (info, username, password);
++}
+diff --git a/src/commands.h b/src/commands.h
+index 38bd5f2..6a14b9b 100644
+--- a/src/commands.h
++++ b/src/commands.h
+@@ -4,7 +4,11 @@
+ #ifndef __COMMANDS__
+ #define __COMMANDS__
+
++#ifdef USE_WEBKIT2
++#include <webkit2/webkit2.h>
++#else
+ #include <webkit/webkit.h>
++#endif
+
+ typedef void (*Command)(WebKitWebView*, GArray *argv, GString *result);
+
+@@ -51,8 +55,29 @@ void search_reverse_text (WebKitWebView *page, GArray *argv, GString *res
+ void search_clear(WebKitWebView *page, GArray *argv, GString *result);
+ void dehilight (WebKitWebView *page, GArray *argv, GString *result);
+ void hardcopy(WebKitWebView *page, GArray *argv, GString *result);
++#ifndef USE_WEBKIT2
++#if WEBKIT_CHECK_VERSION (1, 9, 6)
++void snapshot(WebKitWebView *page, GArray *argv, GString *result);
++#endif
++#endif
++#ifdef USE_WEBKIT2
++#if WEBKIT_CHECK_VERSION (1, 9, 90)
++void load(WebKitWebView *page, GArray *argv, GString *result);
++void save(WebKitWebView *page, GArray *argv, GString *result);
++#endif
++#endif
++void remove_all_db(WebKitWebView *page, GArray *argv, GString *result);
++#if WEBKIT_CHECK_VERSION (1, 3, 8)
++void plugin_refresh(WebKitWebView *page, GArray *argv, GString *result);
++void plugin_toggle(WebKitWebView *page, GArray *argv, GString *result);
++#endif
+ void include(WebKitWebView *page, GArray *argv, GString *result);
++/* Deprecated (use inspector instead) */
+ void show_inspector(WebKitWebView *page, GArray *argv, GString *result);
++void inspector(WebKitWebView *page, GArray *argv, GString *result);
++#if WEBKIT_CHECK_VERSION (1, 5, 1)
++void spell_checker(WebKitWebView *page, GArray *argv, GString *result);
++#endif
+ void add_cookie(WebKitWebView *page, GArray *argv, GString *result);
+ void delete_cookie(WebKitWebView *page, GArray *argv, GString *result);
+ void clear_cookies(WebKitWebView *pag, GArray *argv, GString *result);
+@@ -65,5 +90,6 @@ void toggle_zoom_type (WebKitWebView* page, GArray *argv, GString *result
+ void toggle_status (WebKitWebView* page, GArray *argv, GString *result);
+ void act_dump_config(WebKitWebView* page, GArray *argv, GString *result);
+ void act_dump_config_as_events(WebKitWebView* page, GArray *argv, GString *result);
++void auth(WebKitWebView* page, GArray *argv, GString *result);
+
+ #endif
+diff --git a/src/cookie-jar.c b/src/cookie-jar.c
+index 2f6be83..83facd5 100644
+--- a/src/cookie-jar.c
++++ b/src/cookie-jar.c
+@@ -41,21 +41,21 @@ changed(SoupCookieJar *jar, SoupCookie *old_cookie, SoupCookie *new_cookie) {
+ * propagated to other uzbl instances using add/delete_cookie. */
+ if(!uzbl_jar->in_manual_add) {
+ gchar *scheme = cookie->secure
+- ? cookie->http_only ? "httpsOnly" : "https"
+- : cookie->http_only ? "httpOnly" : "http";
++ ? cookie->http_only ? "httpsOnly" : "https"
++ : cookie->http_only ? "httpOnly" : "http";
+
+ gchar *expires = NULL;
+ if(cookie->expires)
+ expires = g_strdup_printf ("%ld", (long)soup_date_to_time_t (cookie->expires));
+
+- send_event (new_cookie ? ADD_COOKIE : DELETE_COOKIE, NULL,
+- TYPE_STR, cookie->domain,
+- TYPE_STR, cookie->path,
+- TYPE_STR, cookie->name,
+- TYPE_STR, cookie->value,
+- TYPE_STR, scheme,
+- TYPE_STR, expires ? expires : "",
+- NULL);
++ send_event (new_cookie ? ADD_COOKIE : DELETE_COOKIE, NULL,
++ TYPE_STR, cookie->domain,
++ TYPE_STR, cookie->path,
++ TYPE_STR, cookie->name,
++ TYPE_STR, cookie->value,
++ TYPE_STR, scheme,
++ TYPE_STR, expires ? expires : "",
++ NULL);
+
+ if(expires)
+ g_free(expires);
+diff --git a/src/events.c b/src/events.c
+index 081a942..8fc8573 100644
+--- a/src/events.c
++++ b/src/events.c
+@@ -21,7 +21,9 @@ const char *event_table[LAST_EVENT] = {
+ "LOAD_COMMIT" ,
+ "LOAD_FINISH" ,
+ "LOAD_ERROR" ,
++ "REQUEST_QUEUED" ,
+ "REQUEST_STARTING" ,
++ "REQUEST_FINISHED" ,
+ "KEY_PRESS" ,
+ "KEY_RELEASE" ,
+ "MOD_PRESS" ,
+@@ -32,6 +34,7 @@ const char *event_table[LAST_EVENT] = {
+ "GEOMETRY_CHANGED" ,
+ "WEBINSPECTOR" ,
+ "NEW_WINDOW" ,
++ "CLOSE_WINDOW" ,
+ "SELECTION_CHANGED",
+ "VARIABLE_SET" ,
+ "FIFO_SET" ,
+@@ -48,7 +51,6 @@ const char *event_table[LAST_EVENT] = {
+ "PLUG_CREATED" ,
+ "COMMAND_ERROR" ,
+ "BUILTINS" ,
+- "PTR_MOVE" ,
+ "SCROLL_VERT" ,
+ "SCROLL_HORIZ" ,
+ "DOWNLOAD_STARTED" ,
+@@ -57,7 +59,8 @@ const char *event_table[LAST_EVENT] = {
+ "ADD_COOKIE" ,
+ "DELETE_COOKIE" ,
+ "FOCUS_ELEMENT" ,
+- "BLUR_ELEMENT"
++ "BLUR_ELEMENT" ,
++ "AUTHENTICATE"
+ };
+
+ /* for now this is just a alias for GString */
+@@ -168,6 +171,10 @@ vformat_event(int type, const gchar *custom_event, va_list vargs) {
+ g_string_append_printf (event_message, "%d", va_arg (vargs, int));
+ break;
+
++ case TYPE_ULL:
++ g_string_append_printf (event_message, "%llu", va_arg (vargs, unsigned long long));
++ break;
++
+ case TYPE_STR:
+ /* a string that needs to be escaped */
+ g_string_append_c (event_message, '\'');
+@@ -284,10 +291,10 @@ get_modifier_mask(guint state) {
+ g_string_append(modifiers, "Ctrl|");
+ if(state & GDK_MOD1_MASK)
+ g_string_append(modifiers,"Mod1|");
+- /* Mod2 is usually Num_Luck. Ignore it as it messes up keybindings.
++ /* Mod2 is usually Num_Luck. Ignore it as it messes up keybindings.
+ if(state & GDK_MOD2_MASK)
+ g_string_append(modifiers,"Mod2|");
+- */
++ */
+ if(state & GDK_MOD3_MASK)
+ g_string_append(modifiers,"Mod3|");
+ if(state & GDK_MOD4_MASK)
+@@ -349,10 +356,10 @@ guint key_to_modifier(guint keyval) {
+ }
+ }
+
+-guint button_to_modifier(guint buttonval) {
+- if(buttonval <= 5)
+- return 1 << (7 + buttonval);
+- return 0;
++guint button_to_modifier (guint buttonval) {
++ if(buttonval <= 5)
++ return 1 << (7 + buttonval);
++ return 0;
+ }
+
+ /* Transform gdk key events to our own events */
+diff --git a/src/events.h b/src/events.h
+index 73d0712..bd9df33 100644
+--- a/src/events.h
++++ b/src/events.h
+@@ -12,20 +12,21 @@
+ /* Event system */
+ enum event_type {
+ LOAD_START, LOAD_COMMIT, LOAD_FINISH, LOAD_ERROR,
+- REQUEST_STARTING,
++ REQUEST_QUEUED, REQUEST_STARTING, REQUEST_FINISHED,
+ KEY_PRESS, KEY_RELEASE, MOD_PRESS, MOD_RELEASE,
+ COMMAND_EXECUTED,
+ LINK_HOVER, TITLE_CHANGED, GEOMETRY_CHANGED,
+- WEBINSPECTOR, NEW_WINDOW, SELECTION_CHANGED,
++ WEBINSPECTOR, NEW_WINDOW, CLOSE_WINDOW, SELECTION_CHANGED,
+ VARIABLE_SET, FIFO_SET, SOCKET_SET,
+ INSTANCE_START, INSTANCE_EXIT, LOAD_PROGRESS,
+ LINK_UNHOVER, FORM_ACTIVE, ROOT_ACTIVE,
+ FOCUS_LOST, FOCUS_GAINED, FILE_INCLUDED,
+ PLUG_CREATED, COMMAND_ERROR, BUILTINS,
+- PTR_MOVE, SCROLL_VERT, SCROLL_HORIZ,
++ SCROLL_VERT, SCROLL_HORIZ,
+ DOWNLOAD_STARTED, DOWNLOAD_PROGRESS, DOWNLOAD_COMPLETE,
+ ADD_COOKIE, DELETE_COOKIE,
+ FOCUS_ELEMENT, BLUR_ELEMENT,
++ AUTHENTICATE,
+
+ /* must be last entry */
+ LAST_EVENT
+diff --git a/src/inspector.c b/src/inspector.c
+index d0d86b9..d584c77 100644
+--- a/src/inspector.c
++++ b/src/inspector.c
+@@ -8,14 +8,14 @@
+ #include "callbacks.h"
+ #include "type.h"
+
+-void
++static void
+ hide_window_cb(GtkWidget *widget, gpointer data) {
+ (void) data;
+
+ gtk_widget_hide(widget);
+ }
+
+-WebKitWebView*
++static WebKitWebView *
+ create_inspector_cb (WebKitWebInspector* web_inspector, WebKitWebView* page, gpointer data){
+ (void) data;
+ (void) page;
+@@ -44,7 +44,7 @@ create_inspector_cb (WebKitWebInspector* web_inspector, WebKitWebView* page, gpo
+ return WEBKIT_WEB_VIEW(new_web_view);
+ }
+
+-gboolean
++static gboolean
+ inspector_show_window_cb (WebKitWebInspector* inspector){
+ (void) inspector;
+ gtk_widget_show(uzbl.gui.inspector_window);
+@@ -54,32 +54,32 @@ inspector_show_window_cb (WebKitWebInspector* inspector){
+ }
+
+ /* TODO: Add variables and code to make use of these functions */
+-gboolean
++static gboolean
+ inspector_close_window_cb (WebKitWebInspector* inspector){
+ (void) inspector;
+ send_event(WEBINSPECTOR, NULL, TYPE_NAME, "close", NULL);
+ return TRUE;
+ }
+
+-gboolean
++static gboolean
+ inspector_attach_window_cb (WebKitWebInspector* inspector){
+ (void) inspector;
+ return FALSE;
+ }
+
+-gboolean
++static gboolean
+ inspector_detach_window_cb (WebKitWebInspector* inspector){
+ (void) inspector;
+ return FALSE;
+ }
+
+-gboolean
++static gboolean
+ inspector_uri_changed_cb (WebKitWebInspector* inspector){
+ (void) inspector;
+ return FALSE;
+ }
+
+-gboolean
++static gboolean
+ inspector_inspector_destroyed_cb (WebKitWebInspector* inspector){
+ (void) inspector;
+ return FALSE;
+diff --git a/src/io.c b/src/io.c
+index ff418ef..ca3fcf6 100644
+--- a/src/io.c
++++ b/src/io.c
+@@ -47,7 +47,7 @@ control_fifo(GIOChannel *gio, GIOCondition condition) {
+ }
+
+
+-gboolean
++static gboolean
+ attach_fifo(gchar *path) {
+ GError *error = NULL;
+ /* we don't really need to write to the file, but if we open the
+@@ -259,7 +259,7 @@ control_client_socket(GIOChannel *clientchan) {
+ }
+
+
+-gboolean
++static gboolean
+ attach_socket(gchar *path, struct sockaddr_un *local) {
+ GIOChannel *chan = NULL;
+ int sock = socket (AF_UNIX, SOCK_STREAM, 0);
+diff --git a/src/menu.c b/src/menu.c
+index 451b35a..1d9c5b4 100644
+--- a/src/menu.c
++++ b/src/menu.c
+@@ -2,7 +2,7 @@
+ #include "util.h"
+ #include "uzbl-core.h"
+
+-void
++static void
+ add_to_menu(GArray *argv, guint context) {
+ GUI *g = &uzbl.gui;
+ MenuItem *m;
+@@ -68,7 +68,7 @@ menu_add_edit(WebKitWebView *page, GArray *argv, GString *result) {
+ }
+
+
+-void
++static void
+ add_separator_to_menu(GArray *argv, guint context) {
+ GUI *g = &uzbl.gui;
+ MenuItem *m;
+@@ -127,7 +127,7 @@ menu_add_separator_edit(WebKitWebView *page, GArray *argv, GString *result) {
+ }
+
+
+-void
++static void
+ remove_from_menu(GArray *argv, guint context) {
+ GUI *g = &uzbl.gui;
+ MenuItem *mi;
+diff --git a/src/menu.h b/src/menu.h
+index 03055e5..c4ca047 100644
+--- a/src/menu.h
++++ b/src/menu.h
+@@ -1,14 +1,18 @@
+ #ifndef __MENU__
+ #define __MENU__
+
++#ifdef USE_WEBKIT2
++#include <webkit2/webkit2.h>
++#else
+ #include <webkit/webkit.h>
++#endif
+
+ typedef struct {
+ gchar* name;
+ gchar* cmd;
+ gboolean issep;
+ guint context;
+- WebKitHitTestResult* hittest;
++ gchar* argument;
+ } MenuItem;
+
+ void menu_add(WebKitWebView *page, GArray *argv, GString *result);
+diff --git a/src/soup.c b/src/soup.c
+new file mode 100644
+index 0000000..8430018
+--- /dev/null
++++ b/src/soup.c
+@@ -0,0 +1,183 @@
++#include "uzbl-core.h"
++#include "util.h"
++#include "events.h"
++#include "type.h"
++
++static void handle_authentication (SoupSession *session,
++ SoupMessage *msg,
++ SoupAuth *auth,
++ gboolean retrying,
++ gpointer user_data);
++
++static void handle_request_queued (SoupSession *session,
++ SoupMessage *msg,
++ gpointer user_data);
++
++static void handle_request_started (SoupSession *session,
++ SoupMessage *msg,
++ gpointer user_data);
++
++static void handle_request_finished (SoupMessage *msg,
++ gpointer user_data);
++
++struct _PendingAuth
++{
++ SoupAuth *auth;
++ GList *messages;
++};
++typedef struct _PendingAuth PendingAuth;
++
++static PendingAuth *pending_auth_new (SoupAuth *auth);
++static void pending_auth_free (PendingAuth *self);
++static void pending_auth_add_message (PendingAuth *self,
++ SoupMessage *message);
++
++void
++uzbl_soup_init (SoupSession *session)
++{
++ uzbl.net.soup_cookie_jar = uzbl_cookie_jar_new ();
++ uzbl.net.pending_auths = g_hash_table_new_full (
++ g_str_hash, g_str_equal,
++ g_free, pending_auth_free
++ );
++
++ soup_session_add_feature (
++ session,
++ SOUP_SESSION_FEATURE (uzbl.net.soup_cookie_jar)
++ );
++
++ g_signal_connect (
++ session, "request-queued",
++ G_CALLBACK (handle_request_queued), NULL
++ );
++
++ g_signal_connect (
++ session, "request-started",
++ G_CALLBACK (handle_request_started), NULL
++ );
++
++ g_signal_connect (
++ session, "authenticate",
++ G_CALLBACK (handle_authentication), NULL
++ );
++}
++
++void authenticate (const char *authinfo,
++ const char *username,
++ const char *password)
++{
++ PendingAuth *pending = g_hash_table_lookup (
++ uzbl.net.pending_auths,
++ authinfo
++ );
++
++ if (pending == NULL) {
++ return;
++ }
++
++ soup_auth_authenticate (pending->auth, username, password);
++ for(GList *l = pending->messages; l != NULL; l = l->next) {
++ soup_session_unpause_message (
++ uzbl.net.soup_session,
++ SOUP_MESSAGE (l->data)
++ );
++ }
++
++ g_hash_table_remove (uzbl.net.pending_auths, authinfo);
++}
++
++static void
++handle_request_queued (SoupSession *session,
++ SoupMessage *msg,
++ gpointer user_data)
++{
++ (void) session; (void) user_data;
++
++ send_event (
++ REQUEST_QUEUED, NULL,
++ TYPE_STR, soup_uri_to_string (soup_message_get_uri (msg), FALSE),
++ NULL
++ );
++}
++
++static void
++handle_request_started (SoupSession *session,
++ SoupMessage *msg,
++ gpointer user_data)
++{
++ (void) session; (void) user_data;
++
++ send_event (
++ REQUEST_STARTING, NULL,
++ TYPE_STR, soup_uri_to_string (soup_message_get_uri (msg), FALSE),
++ NULL
++ );
++
++ g_signal_connect (
++ G_OBJECT (msg), "finished",
++ G_CALLBACK (handle_request_finished), NULL
++ );
++}
++
++static void
++handle_request_finished (SoupMessage *msg, gpointer user_data)
++{
++ (void) user_data;
++
++ send_event (
++ REQUEST_FINISHED, NULL,
++ TYPE_STR, soup_uri_to_string (soup_message_get_uri (msg), FALSE),
++ NULL
++ );
++}
++
++static void
++handle_authentication (SoupSession *session,
++ SoupMessage *msg,
++ SoupAuth *auth,
++ gboolean retrying,
++ gpointer user_data)
++{
++ (void) user_data;
++ PendingAuth *pending;
++ char *authinfo = soup_auth_get_info (auth);
++
++ pending = g_hash_table_lookup (uzbl.net.pending_auths, authinfo);
++ if (pending == NULL) {
++ pending = pending_auth_new (auth);
++ g_hash_table_insert (uzbl.net.pending_auths, authinfo, pending);
++ }
++
++ pending_auth_add_message (pending, msg);
++ soup_session_pause_message (session, msg);
++
++ send_event (
++ AUTHENTICATE, NULL,
++ TYPE_STR, authinfo,
++ TYPE_STR, soup_auth_get_host (auth),
++ TYPE_STR, soup_auth_get_realm (auth),
++ TYPE_STR, (retrying ? "retrying" : ""),
++ NULL
++ );
++}
++
++static PendingAuth *pending_auth_new (SoupAuth *auth)
++{
++ PendingAuth *self = g_new (PendingAuth, 1);
++ self->auth = auth;
++ self->messages = NULL;
++ g_object_ref (auth);
++ return self;
++}
++
++static void pending_auth_free (PendingAuth *self)
++{
++ g_object_unref (self->auth);
++ g_list_free_full (self->messages, g_object_unref);
++ g_free (self);
++}
++
++static void pending_auth_add_message (PendingAuth *self, SoupMessage *message)
++{
++ self->messages = g_list_append (self->messages, g_object_ref (message));
++}
+diff --git a/src/soup.h b/src/soup.h
+new file mode 100644
+index 0000000..ce7d605
+--- /dev/null
++++ b/src/soup.h
+@@ -0,0 +1,18 @@
++/**
++ * Uzbl tweaks and extension for soup
++ */
++
++#ifndef __UZBL_SOUP__
++#define __UZBL_SOUP__
++
++#include <libsoup/soup.h>
++
++/**
++ * Attach uzbl specific behaviour to the given SoupSession
++ */
++void uzbl_soup_init (SoupSession *session);
++
++void authenticate (const char *authinfo,
++ const char *username,
++ const char *password);
++#endif
+diff --git a/src/status-bar.h b/src/status-bar.h
+index cae8905..1fd4ef2 100644
+--- a/src/status-bar.h
++++ b/src/status-bar.h
+@@ -10,7 +10,7 @@
+ #define UZBL_IS_STATUS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UZBL_TYPE_STATUS_BAR))
+ #define UZBL_STATUS_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UZBL_TYPE_STATUS_BAR, UzblStatusBarClass))
+
+-typedef struct _UzblStatusBar UzblStatusBar;
++typedef struct _UzblStatusBar UzblStatusBar;
+ typedef struct _UzblStatusBarClass UzblStatusBarClass;
+
+ struct _UzblStatusBar {
+diff --git a/src/type.h b/src/type.h
+index eda02c1..826ca3b 100644
+--- a/src/type.h
++++ b/src/type.h
+@@ -9,6 +9,7 @@ enum ptr_type {
+ TYPE_INT = 1,
+ TYPE_STR,
+ TYPE_FLOAT,
++ TYPE_ULL,
+ TYPE_NAME,
+ // used by send_event
+ TYPE_FORMATTEDSTR,
+@@ -24,6 +25,7 @@ enum ptr_type {
+ typedef union uzbl_value_ptr_t {
+ int *i;
+ float *f;
++ unsigned long long *ull;
+ gchar **s;
+ } uzbl_value_ptr;
+
+diff --git a/src/util.c b/src/util.c
+index 1468d23..3f7f093 100644
+--- a/src/util.c
++++ b/src/util.c
+@@ -195,3 +195,9 @@ append_escaped (GString *dest, const gchar *src) {
+ }
+ return dest;
+ }
++
++void
++sharg_append (GArray *a, const gchar *str) {
++ const gchar *s = (str ? str : "");
++ g_array_append_val(a, s);
++}
+diff --git a/src/util.h b/src/util.h
+index cc29247..e0a8bbd 100644
+--- a/src/util.h
++++ b/src/util.h
+@@ -12,7 +12,11 @@ char* str_replace(const char* search, const char* replace, const char* str
+ gboolean for_each_line_in_file(const gchar *path, void (*callback)(const gchar *l, void *c), void *user_data);
+ gchar* find_existing_file(const gchar*);
+ gchar* argv_idx(const GArray*, const guint);
++
+ /**
+ * appends `src' to `dest' with backslash, single-quotes and newlines in
+- * `src' escaped */
++ * `src' escaped
++ */
+ GString * append_escaped (GString *dest, const gchar *src);
++
++void sharg_append (GArray *array, const gchar *str);
+diff --git a/src/uzbl-core.c b/src/uzbl-core.c
+index 1288f22..748202f 100644
+--- a/src/uzbl-core.c
++++ b/src/uzbl-core.c
+@@ -39,6 +39,7 @@
+ #include "io.h"
+ #include "variables.h"
+ #include "type.h"
++#include "soup.h"
+
+ UzblCore uzbl;
+
+@@ -279,22 +280,6 @@ clean_up(void) {
+ }
+ }
+
+-gint
+-get_click_context() {
+- GUI *g = &uzbl.gui;
+- WebKitHitTestResult *ht;
+- guint context;
+-
+- if(!uzbl.state.last_button)
+- return -1;
+-
+- ht = webkit_web_view_get_hit_test_result (g->web_view, uzbl.state.last_button);
+- g_object_get (ht, "context", &context, NULL);
+- g_object_unref (ht);
+-
+- return (gint)context;
+-}
+-
+ /* --- SIGNALS --- */
+ sigfunc*
+ setup_signal(int signr, sigfunc *shandler) {
+@@ -310,7 +295,7 @@ setup_signal(int signr, sigfunc *shandler) {
+ return NULL;
+ }
+
+-void
++static void
+ empty_event_buffer(int s) {
+ (void) s;
+ if(uzbl.state.event_buffer) {
+@@ -356,12 +341,12 @@ parse_cmd_line_cb(const char *line, void *user_data) {
+ }
+
+ void
+-run_command_file(const gchar *path) {
+- if(!for_each_line_in_file(path, parse_cmd_line_cb, NULL)) {
+- gchar *tmp = g_strdup_printf("File %s can not be read.", path);
+- send_event(COMMAND_ERROR, NULL, TYPE_STR, tmp, NULL);
+- g_free(tmp);
+- }
++run_command_file (const gchar *path) {
++ if(!for_each_line_in_file(path, parse_cmd_line_cb, NULL)) {
++ gchar *tmp = g_strdup_printf("File %s can not be read.", path);
++ send_event(COMMAND_ERROR, NULL, TYPE_STR, tmp, NULL);
++ g_free(tmp);
++ }
+ }
+
+ /* Javascript*/
+@@ -463,12 +448,6 @@ search_text (WebKitWebView *page, const gchar *key, const gboolean forward) {
+ }
+ }
+
+-void
+-sharg_append(GArray *a, const gchar *str) {
+- const gchar *s = (str ? str : "");
+- g_array_append_val(a, s);
+-}
+-
+ /* make sure that the args string you pass can properly be interpreted (eg
+ * properly escaped against whitespace, quotes etc) */
+ gboolean
+@@ -517,7 +496,7 @@ run_command (const gchar *command, const gchar **args, const gboolean sync,
+ return result;
+ }
+
+-/*@null@*/ gchar**
++/*@null@*/ static gchar**
+ split_quoted(const gchar* src, const gboolean unquote) {
+ /* split on unquoted space or tab, return array of strings;
+ remove a layer of quotes and backslashes if unquote */
+@@ -769,7 +748,6 @@ create_scrolled_win() {
+ "signal::key-release-event", (GCallback)key_release_cb, NULL,
+ "signal::button-press-event", (GCallback)button_press_cb, NULL,
+ "signal::button-release-event", (GCallback)button_release_cb, NULL,
+- "signal::motion-notify-event", (GCallback)motion_notify_cb, NULL,
+ "signal::notify::title", (GCallback)title_change_cb, NULL,
+ "signal::notify::progress", (GCallback)progress_change_cb, NULL,
+ "signal::notify::load-status", (GCallback)load_status_change_cb, NULL,
+@@ -777,12 +755,16 @@ create_scrolled_win() {
+ "signal::load-error", (GCallback)load_error_cb, NULL,
+ "signal::hovering-over-link", (GCallback)link_hover_cb, NULL,
+ "signal::navigation-policy-decision-requested", (GCallback)navigation_decision_cb, NULL,
+- "signal::new-window-policy-decision-requested", (GCallback)new_window_cb, NULL,
++ "signal::close-web-view", (GCallback)close_web_view_cb, NULL,
+ "signal::download-requested", (GCallback)download_cb, NULL,
+ "signal::create-web-view", (GCallback)create_web_view_cb, NULL,
+ "signal::mime-type-policy-decision-requested", (GCallback)mime_policy_cb, NULL,
+ "signal::resource-request-starting", (GCallback)request_starting_cb, NULL,
++#if WEBKIT_CHECK_VERSION (1, 9, 0)
++ "signal::context-menu", (GCallback)context_menu_cb, NULL,
++#else
+ "signal::populate-popup", (GCallback)populate_popup_cb, NULL,
++#endif
+ "signal::focus-in-event", (GCallback)focus_cb, NULL,
+ "signal::focus-out-event", (GCallback)focus_cb, NULL,
+ "signal::window-object-cleared", (GCallback)window_object_cleared_cb,NULL,
+@@ -822,7 +804,6 @@ create_plug() {
+ void
+ settings_init () {
+ State* s = &uzbl.state;
+- Network* n = &uzbl.net;
+ int i;
+
+ /* Load default config */
+@@ -841,70 +822,13 @@ settings_init () {
+
+ /* Load config file, if any */
+ if (s->config_file) {
+- run_command_file(s->config_file);
++ run_command_file(s->config_file);
+ g_setenv("UZBL_CONFIG", s->config_file, TRUE);
+ } else if (uzbl.state.verbose)
+ printf ("No configuration file loaded.\n");
+
+ if (s->connect_socket_names)
+ init_connect_socket();
+-
+- g_signal_connect(n->soup_session, "authenticate", G_CALLBACK(handle_authentication), NULL);
+-}
+-
+-
+-void handle_authentication (SoupSession *session, SoupMessage *msg, SoupAuth *auth, gboolean retrying, gpointer user_data) {
+- (void) user_data;
+-
+- if (uzbl.behave.authentication_handler && *uzbl.behave.authentication_handler != 0) {
+- soup_session_pause_message(session, msg);
+-
+- GString *result = g_string_new ("");
+-
+- gchar *info = g_strdup(soup_auth_get_info(auth));
+- gchar *host = g_strdup(soup_auth_get_host(auth));
+- gchar *realm = g_strdup(soup_auth_get_realm(auth));
+-
+- GArray *a = g_array_new (TRUE, FALSE, sizeof(gchar*));
+- const CommandInfo *c = parse_command_parts(uzbl.behave.authentication_handler, a);
+- if(c) {
+- sharg_append(a, info);
+- sharg_append(a, host);
+- sharg_append(a, realm);
+- sharg_append(a, retrying ? "TRUE" : "FALSE");
+-
+- run_parsed_command(c, a, result);
+- }
+- g_array_free(a, TRUE);
+-
+- if (result->len > 0) {
+- char *username, *password;
+- int number_of_endls=0;
+-
+- username = result->str;
+-
+- gchar *p;
+- for (p = result->str; *p; p++) {
+- if (*p == '\n') {
+- *p = '\0';
+- if (++number_of_endls == 1)
+- password = p + 1;
+- }
+- }
+-
+- /* If stdout was correct (contains exactly two lines of text) do
+- * authenticate. */
+- if (number_of_endls == 2)
+- soup_auth_authenticate(auth, username, password);
+- }
+-
+- soup_session_unpause_message(session, msg);
+-
+- g_string_free(result, TRUE);
+- g_free(info);
+- g_free(host);
+- g_free(realm);
+- }
+ }
+
+ /* Set up gtk, gobject, variable defaults and other things that tests and other
+@@ -922,11 +846,19 @@ initialize(int argc, char** argv) {
+ uzbl.info.webkit_major = webkit_major_version();
+ uzbl.info.webkit_minor = webkit_minor_version();
+ uzbl.info.webkit_micro = webkit_micro_version();
++#ifdef USE_WEBKIT2
++ uzbl.info.webkit2 = 1;
++#else
++ uzbl.info.webkit2 = 0;
++#endif
+ uzbl.info.arch = ARCH;
+ uzbl.info.commit = COMMIT;
+
+ uzbl.state.last_result = NULL;
+
++ /* BUG There isn't a getter for this; need to maintain separately. */
++ uzbl.behave.maintain_history = TRUE;
++
+ /* Parse commandline arguments */
+ GOptionContext* context = g_option_context_new ("[ uri ] - load a uri by default");
+ g_option_context_add_main_entries(context, entries, NULL);
+@@ -956,10 +888,8 @@ initialize(int argc, char** argv) {
+ event_buffer_timeout(10);
+
+ /* HTTP client */
+- uzbl.net.soup_session = webkit_get_default_session();
+- uzbl.net.soup_cookie_jar = uzbl_cookie_jar_new();
+-
+- soup_session_add_feature(uzbl.net.soup_session, SOUP_SESSION_FEATURE(uzbl.net.soup_cookie_jar));
++ uzbl.net.soup_session = webkit_get_default_session();
++ uzbl_soup_init (uzbl.net.soup_session);
+
+ commands_hash();
+ variables_hash();
+@@ -1081,6 +1011,13 @@ main (int argc, char* argv[]) {
+
+ gboolean verbose_override = uzbl.state.verbose;
+
++ /* Finally show the window */
++ if (uzbl.gui.main_window) {
++ gtk_widget_show_all (uzbl.gui.main_window);
++ } else {
++ gtk_widget_show_all (GTK_WIDGET (uzbl.gui.plug));
++ }
++
+ /* Read configuration file */
+ settings_init();
+
+@@ -1099,13 +1036,6 @@ main (int argc, char* argv[]) {
+ g_free(uri_override);
+ }
+
+- /* Finally show the window */
+- if (uzbl.gui.main_window) {
+- gtk_widget_show_all (uzbl.gui.main_window);
+- } else {
+- gtk_widget_show_all (GTK_WIDGET (uzbl.gui.plug));
+- }
+-
+ /* Verbose feedback */
+ if (uzbl.state.verbose) {
+ printf("Uzbl start location: %s\n", argv[0]);
+diff --git a/src/uzbl-core.h b/src/uzbl-core.h
+index 1f9613e..6f27818 100644
+--- a/src/uzbl-core.h
++++ b/src/uzbl-core.h
+@@ -23,7 +23,11 @@
+ #include <sys/un.h>
+ #include <sys/utsname.h>
+ #include <sys/time.h>
++#ifdef USE_WEBKIT2
++#include <webkit2/webkit2.h>
++#else
+ #include <webkit/webkit.h>
++#endif
+ #include <libsoup/soup.h>
+ #include <JavaScriptCore/JavaScript.h>
+
+@@ -78,6 +82,7 @@ typedef struct {
+ WebKitWebInspector* inspector;
+
+ /* Custom context menu item */
++ gboolean custom_context_menu;
+ GPtrArray* menu_items;
+ } GUI;
+
+@@ -114,6 +119,9 @@ typedef struct {
+ gboolean handle_multi_button;
+ GPtrArray* event_buffer;
+ gchar** connect_socket_names;
++
++ /* Temporary web view used when a new window is opened */
++ WebKitWebView* _tmp_web_view;
+ } State;
+
+
+@@ -121,6 +129,7 @@ typedef struct {
+ typedef struct {
+ SoupSession* soup_session;
+ UzblCookieJar* soup_cookie_jar;
++ GHashTable* pending_auths;
+ SoupLogger* soup_logger;
+ char* proxy_url;
+ char* useragent;
+@@ -129,12 +138,6 @@ typedef struct {
+ gint max_conns_host;
+ } Network;
+
+-/* ssl */
+-typedef struct {
+- gchar *ca_file;
+- gchar *verify_cert;
+-} Ssl;
+-
+ /* Behaviour */
+ typedef struct {
+ /* Status bar */
+@@ -161,6 +164,7 @@ typedef struct {
+ guint http_debug;
+ gchar* shell_cmd;
+ guint view_source;
++ gboolean maintain_history;
+
+ gboolean print_version;
+
+@@ -176,6 +180,7 @@ typedef struct {
+ int webkit_major;
+ int webkit_minor;
+ int webkit_micro;
++ int webkit2;
+ gchar* arch;
+ gchar* commit;
+
+@@ -189,7 +194,6 @@ typedef struct {
+ GUI gui;
+ State state;
+ Network net;
+- Ssl ssl;
+ Behaviour behave;
+ Communication comm;
+ Info info;
+@@ -245,19 +249,12 @@ void search_text (WebKitWebView *page, const gchar *key, const gboolean f
+ void eval_js(WebKitWebView *web_view, const gchar *script, GString *result, const gchar *script_file);
+
+ /* Network functions */
+-void handle_authentication (SoupSession *session,
+- SoupMessage *msg,
+- SoupAuth *auth,
+- gboolean retrying,
+- gpointer user_data);
+-
+ void init_connect_socket();
+ gboolean remove_socket_from_array(GIOChannel *chan);
+
+ /* Window */
+ void retrieve_geometry();
+ void scroll(GtkAdjustment* bar, gchar *amount_str);
+-gint get_click_context();
+
+
+ #endif
+diff --git a/src/variables.c b/src/variables.c
+index e4763bc..749a176 100644
+--- a/src/variables.c
++++ b/src/variables.c
+@@ -5,6 +5,8 @@
+ #include "io.h"
+ #include "util.h"
+
++#include <stdlib.h>
++
+ uzbl_cmdprop *
+ get_var_c(const gchar *name) {
+ return g_hash_table_lookup(uzbl.behave.proto_var, name);
+@@ -32,6 +34,13 @@ send_set_var_event(const char *name, const uzbl_cmdprop *c) {
+ TYPE_INT, get_var_value_int_c(c),
+ NULL);
+ break;
++ case TYPE_ULL:
++ send_event (VARIABLE_SET, NULL,
++ TYPE_NAME, name,
++ TYPE_NAME, "ull",
++ TYPE_ULL, get_var_value_ull_c(c),
++ NULL);
++ break;
+ case TYPE_FLOAT:
+ send_event (VARIABLE_SET, NULL,
+ TYPE_NAME, name,
+@@ -78,6 +87,14 @@ set_var_value_int_c(uzbl_cmdprop *c, int i) {
+ }
+
+ void
++set_var_value_ull_c(uzbl_cmdprop *c, unsigned long long ull) {
++ if(c->setter)
++ ((void (*)(unsigned long long))c->setter)(ull);
++ else
++ *(c->ptr.ull) = ull;
++}
++
++void
+ set_var_value_float_c(uzbl_cmdprop *c, float f) {
+ if(c->setter)
+ ((void (*)(float))c->setter)(f);
+@@ -100,10 +117,16 @@ set_var_value(const gchar *name, gchar *val) {
+ break;
+ case TYPE_INT:
+ {
+- int i = (int)strtoul(val, NULL, 10);
++ int i = (int)strtol(val, NULL, 10);
+ set_var_value_int_c(c, i);
+ break;
+ }
++ case TYPE_ULL:
++ {
++ unsigned long long ull = strtoull(val, NULL, 10);
++ set_var_value_ull_c(c, ull);
++ break;
++ }
+ case TYPE_FLOAT:
+ {
+ float f = strtod(val, NULL);
+@@ -184,6 +207,24 @@ get_var_value_int(const gchar *name) {
+ return get_var_value_int_c(c);
+ }
+
++unsigned long long
++get_var_value_ull_c(const uzbl_cmdprop *c) {
++ if(!c) return 0;
++
++ if(c->getter) {
++ return ((unsigned long long (*)())c->getter)();
++ } else if(c->ptr.ull)
++ return *(c->ptr.ull);
++
++ return 0;
++}
++
++unsigned long long
++get_var_value_ull(const gchar *name) {
++ uzbl_cmdprop *c = get_var_c(name);
++ return get_var_value_ull_c(c);
++}
++
+ float
+ get_var_value_float_c(const uzbl_cmdprop *c) {
+ if(!c) return 0;
+@@ -202,7 +243,7 @@ get_var_value_float(const gchar *name) {
+ return get_var_value_float_c(c);
+ }
+
+-void
++static void
+ dump_var_hash(gpointer k, gpointer v, gpointer ud) {
+ (void) ud;
+ uzbl_cmdprop *c = v;
+@@ -214,10 +255,13 @@ dump_var_hash(gpointer k, gpointer v, gpointer ud) {
+ gchar *v = get_var_value_string_c(c);
+ printf("set %s = %s\n", (char *)k, v);
+ g_free(v);
+- } else if(c->type == TYPE_INT)
++ } else if(c->type == TYPE_INT) {
+ printf("set %s = %d\n", (char *)k, get_var_value_int_c(c));
+- else if(c->type == TYPE_FLOAT)
++ } else if(c->type == TYPE_ULL) {
++ printf("set %s = %llu\n", (char *)k, get_var_value_ull_c(c));
++ } else if(c->type == TYPE_FLOAT) {
+ printf("set %s = %f\n", (char *)k, get_var_value_float_c(c));
++ }
+ }
+
+ void
+@@ -225,7 +269,7 @@ dump_config() {
+ g_hash_table_foreach(uzbl.behave.proto_var, dump_var_hash, NULL);
+ }
+
+-void
++static void
+ dump_var_hash_as_event(gpointer k, gpointer v, gpointer ud) {
+ (void) ud;
+ uzbl_cmdprop *c = v;
+@@ -240,18 +284,23 @@ dump_config_as_events() {
+ }
+
+ /* is the given string made up entirely of decimal digits? */
+-gboolean
++static gboolean
+ string_is_integer(const char *s) {
+ return (strspn(s, "0123456789") == strlen(s));
+ }
+
+
+-GObject*
++static GObject *
++cookie_jar() {
++ return G_OBJECT(uzbl.net.soup_cookie_jar);
++}
++
++static GObject *
+ view_settings() {
+ return G_OBJECT(webkit_web_view_get_settings(uzbl.gui.web_view));
+ }
+
+-void
++static void
+ set_window_property(const gchar* prop, const gchar* value) {
+ if(GTK_IS_WIDGET(uzbl.gui.main_window)) {
+ gdk_property_change(
+@@ -276,7 +325,7 @@ uri_change_cb (WebKitWebView *web_view, GParamSpec param_spec) {
+ set_window_property("UZBL_URI", uzbl.state.uri);
+ }
+
+-gchar *
++static gchar *
+ make_uri_from_user_input(const gchar *uri) {
+ gchar *result = NULL;
+
+@@ -312,7 +361,7 @@ make_uri_from_user_input(const gchar *uri) {
+ return g_strconcat("http://", uri, NULL);
+ }
+
+-void
++static void
+ set_uri(const gchar *uri) {
+ /* Strip leading whitespace */
+ while (*uri && isspace(*uri))
+@@ -340,7 +389,7 @@ set_uri(const gchar *uri) {
+ g_free (newuri);
+ }
+
+-void
++static void
+ set_max_conns(int max_conns) {
+ uzbl.net.max_conns = max_conns;
+
+@@ -348,7 +397,7 @@ set_max_conns(int max_conns) {
+ SOUP_SESSION_MAX_CONNS, uzbl.net.max_conns, NULL);
+ }
+
+-void
++static void
+ set_max_conns_host(int max_conns_host) {
+ uzbl.net.max_conns_host = max_conns_host;
+
+@@ -356,7 +405,7 @@ set_max_conns_host(int max_conns_host) {
+ SOUP_SESSION_MAX_CONNS_PER_HOST, uzbl.net.max_conns_host, NULL);
+ }
+
+-void
++static void
+ set_http_debug(int debug) {
+ uzbl.behave.http_debug = debug;
+
+@@ -371,77 +420,258 @@ set_http_debug(int debug) {
+ SOUP_SESSION_FEATURE(uzbl.net.soup_logger));
+ }
+
+-void
++static void
+ set_ca_file(gchar *path) {
+ g_object_set (uzbl.net.soup_session, "ssl-ca-file", path, NULL);
+ }
+
+-gchar *
++static gchar *
+ get_ca_file() {
+ gchar *path;
+ g_object_get (uzbl.net.soup_session, "ssl-ca-file", &path, NULL);
+ return path;
+ }
+
+-void
+-set_verify_cert(int strict) {
+- g_object_set (uzbl.net.soup_session, "ssl-strict", strict, NULL);
++#define EXPOSE_WEB_INSPECTOR_SETTINGS(SYM, PROPERTY, TYPE) \
++static void set_##SYM(TYPE val) { \
++ g_object_set(uzbl.gui.inspector, (PROPERTY), val, NULL); \
++} \
++static TYPE get_##SYM() { \
++ TYPE val; \
++ g_object_get(uzbl.gui.inspector, (PROPERTY), &val, NULL); \
++ return val; \
+ }
+
+-int
+-get_verify_cert() {
+- int strict;
+- g_object_get (uzbl.net.soup_session, "ssl-strict", &strict, NULL);
+- return strict;
++EXPOSE_WEB_INSPECTOR_SETTINGS(profile_js, "javascript-profiling-enabled", int)
++EXPOSE_WEB_INSPECTOR_SETTINGS(profile_timeline, "timeline-profiling-enabled", gchar *)
++
++#undef EXPOSE_WEB_INSPECTOR_SETTINGS
++
++#define EXPOSE_SOUP_SESSION_SETTINGS(SYM, PROPERTY, TYPE) \
++static void set_##SYM(TYPE val) { \
++ g_object_set(uzbl.net.soup_session, (PROPERTY), val, NULL); \
++} \
++static TYPE get_##SYM() { \
++ TYPE val; \
++ g_object_get(uzbl.net.soup_session, (PROPERTY), &val, NULL); \
++ return val; \
+ }
+
++EXPOSE_SOUP_SESSION_SETTINGS(verify_cert, "ssl-strict", int)
++
++#undef EXPOSE_SOUP_SESSION_SETTINGS
++
++#define EXPOSE_SOUP_COOKIE_JAR_SETTINGS(SYM, PROPERTY, TYPE) \
++static void set_##SYM(TYPE val) { \
++ g_object_set(cookie_jar(), (PROPERTY), val, NULL); \
++} \
++static TYPE get_##SYM() { \
++ TYPE val; \
++ g_object_get(cookie_jar(), (PROPERTY), &val, NULL); \
++ return val; \
++}
++
++EXPOSE_SOUP_COOKIE_JAR_SETTINGS(cookie_policy, "accept-policy", int)
++
++#undef EXPOSE_SOUP_COOKIE_JAR_SETTINGS
++
++#define EXPOSE_WEBKIT_VIEW_VIEW_SETTINGS(SYM, PROPERTY, TYPE) \
++static void set_##SYM(TYPE val) { \
++ g_object_set(uzbl.gui.web_view, (PROPERTY), val, NULL); \
++} \
++static TYPE get_##SYM() { \
++ TYPE val; \
++ g_object_get(uzbl.gui.web_view, (PROPERTY), &val, NULL); \
++ return val; \
++}
++
++EXPOSE_WEBKIT_VIEW_VIEW_SETTINGS(editable, "editable", int)
++EXPOSE_WEBKIT_VIEW_VIEW_SETTINGS(transparent, "transparent", int)
++
++#undef EXPOSE_WEBKIT_VIEW_SETTINGS
++
+ #define EXPOSE_WEBKIT_VIEW_SETTINGS(SYM, PROPERTY, TYPE) \
+-void set_##SYM(TYPE val) { \
++static void set_##SYM(TYPE val) { \
+ g_object_set(view_settings(), (PROPERTY), val, NULL); \
+ } \
+-TYPE get_##SYM() { \
++static TYPE get_##SYM() { \
+ TYPE val; \
+ g_object_get(view_settings(), (PROPERTY), &val, NULL); \
+ return val; \
+ }
+
+-EXPOSE_WEBKIT_VIEW_SETTINGS(default_font_family, "default-font-family", gchar *)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(monospace_font_family, "monospace-font-family", gchar *)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(sans_serif_font_family, "sans_serif-font-family", gchar *)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(serif_font_family, "serif-font-family", gchar *)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(cursive_font_family, "cursive-font-family", gchar *)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(fantasy_font_family, "fantasy-font-family", gchar *)
++/* Font settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(default_font_family, "default-font-family", gchar *)
++EXPOSE_WEBKIT_VIEW_SETTINGS(monospace_font_family, "monospace-font-family", gchar *)
++EXPOSE_WEBKIT_VIEW_SETTINGS(sans_serif_font_family, "sans_serif-font-family", gchar *)
++EXPOSE_WEBKIT_VIEW_SETTINGS(serif_font_family, "serif-font-family", gchar *)
++EXPOSE_WEBKIT_VIEW_SETTINGS(cursive_font_family, "cursive-font-family", gchar *)
++EXPOSE_WEBKIT_VIEW_SETTINGS(fantasy_font_family, "fantasy-font-family", gchar *)
++
++/* Font size settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(minimum_font_size, "minimum-font-size", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(font_size, "default-font-size", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(monospace_size, "default-monospace-font-size", int)
++
++/* Text settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(default_encoding, "default-encoding", gchar *)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enforce_96_dpi, "enforce-96-dpi", int)
++
++/* Feature settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_plugins, "enable-plugins", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_java_applet, "enable-java-applet", int)
++#if WEBKIT_CHECK_VERSION (1, 3, 14)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_webgl, "enable-webgl", int)
++#endif
++#if WEBKIT_CHECK_VERSION (1, 7, 5)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_webaudio, "enable-webaudio", int)
++#endif
++#if WEBKIT_CHECK_VERSION (1, 7, 90) // Documentation says 1.7.5, but it's not there.
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_3d_acceleration, "enable-accelerated-compositing", int)
++#endif
++#if WEBKIT_CHECK_VERSION (1, 11, 1)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_css_shaders, "enable-css-shaders", int)
++#endif
+
+-EXPOSE_WEBKIT_VIEW_SETTINGS(minimum_font_size, "minimum-font-size", int)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(font_size, "default-font-size", int)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(monospace_size, "default-monospace-font-size", int)
++/* HTML5 Database settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_database, "enable-html5-database", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_local_storage, "enable-html5-local-storage", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_pagecache, "enable-page-cache", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_offline_app_cache, "enable-offline-web-application-cache", int)
++#if WEBKIT_CHECK_VERSION (1, 5, 2)
++EXPOSE_WEBKIT_VIEW_SETTINGS(local_storage_path, "html5-local-storage-database-path", gchar *)
++#endif
+
+-EXPOSE_WEBKIT_VIEW_SETTINGS(enable_plugins, "enable-plugins", int)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(enable_scripts, "enable-scripts", int)
++/* Security settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_private_webkit, "enable-private-browsing", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_universal_file_access, "enable-universal-access-from-file-uris", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_cross_file_access, "enable-file-access-from-file-uris", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_hyperlink_auditing, "enable-hyperlink-auditing", int)
++#if WEBKIT_CHECK_VERSION (1, 3, 13)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_dns_prefetch, "enable-dns-prefetching", int)
++#endif
++#if WEBKIT_CHECK_VERSION (1, 11, 2)
++EXPOSE_WEBKIT_VIEW_SETTINGS(display_insecure_content, "enable-display-of-insecure-content", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(run_insecure_content, "enable-running-of-insecure-content", int)
++#endif
+
+-EXPOSE_WEBKIT_VIEW_SETTINGS(javascript_windows, "javascript-can-open-windows-automatically", int)
++/* Display settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(zoom_step, "zoom-step", float)
++EXPOSE_WEBKIT_VIEW_SETTINGS(caret_browsing, "enable-caret-browsing", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(auto_resize_window, "auto-resize-window", int)
++#if WEBKIT_CHECK_VERSION (1, 3, 5)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_frame_flattening, "enable-frame-flattening", int)
++#endif
++#if WEBKIT_CHECK_VERSION (1, 3, 8)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_fullscreen, "enable-fullscreen", int)
++#endif
++#ifdef USE_WEBKIT2
++#if WEBKIT_CHECK_VERSION (1, 7, 91)
++EXPOSE_WEBKIT_VIEW_SETTINGS(zoom_text_only, "zoom-text-only", int)
++#endif
++#endif
++#if WEBKIT_CHECK_VERSION (1, 9, 0)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_smooth_scrolling, "enable-smooth-scrolling", int)
++#endif
+
+-EXPOSE_WEBKIT_VIEW_SETTINGS(autoload_images, "auto-load-images", int)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(autoshrink_images, "auto-shrink-images", int)
++/* Javascript settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_scripts, "enable-scripts", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(javascript_windows, "javascript-can-open-windows-automatically", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(javascript_dom_paste, "enable-dom-paste", int)
++#if WEBKIT_CHECK_VERSION (1, 3, 0)
++EXPOSE_WEBKIT_VIEW_SETTINGS(javascript_clipboard, "javascript-can-access-clipboard", int)
++#endif
+
+-EXPOSE_WEBKIT_VIEW_SETTINGS(enable_pagecache, "enable-page-cache", int)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(enable_private, "enable-private-browsing", int)
++/* Media settings */
++#if WEBKIT_CHECK_VERSION (1, 9, 3)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_inline_media, "media-playback-allows-inline", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(require_click_to_play, "media-playback-requires-user-gesture", int)
++#endif
++#if WEBKIT_CHECK_VERSION (1, 11, 1)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_media_stream, "enable-media-stream", int)
++#endif
+
+-EXPOSE_WEBKIT_VIEW_SETTINGS(enable_spellcheck, "enable-spell-checking", int)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(spellcheck_languages, "spell-checking-languages", gchar *)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(resizable_text_areas, "resizable-text-areas", int)
++/* Image settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(autoload_images, "auto-load-images", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(autoshrink_images, "auto-shrink-images", int)
+
+-EXPOSE_WEBKIT_VIEW_SETTINGS(stylesheet_uri, "user-stylesheet-uri", gchar *)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(print_bg, "print-backgrounds", int)
+-EXPOSE_WEBKIT_VIEW_SETTINGS(enforce_96_dpi, "enforce-96-dpi", int)
++/* Spell checking settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_spellcheck, "enable-spell-checking", int)
+
+-EXPOSE_WEBKIT_VIEW_SETTINGS(caret_browsing, "enable-caret-browsing", int)
++/* Form settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(resizable_text_areas, "resizable-text-areas", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_spatial_navigation, "enable-spatial-navigation", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(editing_behavior, "editing-behavior", int)
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_tab_cycle, "tab-key-cycles-through-elements", int)
+
+-EXPOSE_WEBKIT_VIEW_SETTINGS(enable_cross_file_access, "enable-file-access-from-file-uris", int)
++/* Customization */
++EXPOSE_WEBKIT_VIEW_SETTINGS(stylesheet_uri, "user-stylesheet-uri", gchar *)
++#if !WEBKIT_CHECK_VERSION (1, 9, 0)
++EXPOSE_WEBKIT_VIEW_SETTINGS(default_context_menu, "enable-default-context-menu", int)
++#endif
+
+-EXPOSE_WEBKIT_VIEW_SETTINGS(default_encoding, "default-encoding", gchar *)
++/* Hacks */
++EXPOSE_WEBKIT_VIEW_SETTINGS(enable_site_workarounds, "enable-site-specific-quirks", int)
+
+-void
++/* Printing settings */
++EXPOSE_WEBKIT_VIEW_SETTINGS(print_bg, "print-backgrounds", int)
++
++#undef EXPOSE_WEBKIT_VIEW_SETTINGS
++
++static void
++set_maintain_history (int maintain) {
++ uzbl.behave.maintain_history = maintain;
++
++ webkit_web_view_set_maintains_back_forward_list (uzbl.gui.web_view, maintain);
++}
++
++static int
++get_maintain_history () {
++ return uzbl.behave.maintain_history;
++}
++
++static void
++set_spellcheck_languages(const gchar *languages) {
++ GObject *obj = webkit_get_text_checker ();
++
++ if (!obj) {
++ return;
++ }
++ if (!WEBKIT_IS_SPELL_CHECKER (obj)) {
++ return;
++ }
++
++ WebKitSpellChecker *checker = WEBKIT_SPELL_CHECKER (obj);
++
++ webkit_spell_checker_update_spell_checking_languages (checker, languages);
++ g_object_set(view_settings(), "spell-checking-languages", languages, NULL);
++}
++
++static gchar *
++get_spellcheck_languages() {
++ gchar *val;
++ g_object_get(view_settings(), "spell-checking-languages", &val, NULL);
++ return val;
++}
++
++static void
++set_enable_private (int private) {
++ const char *priv_envvar = "UZBL_PRIVATE";
++
++ if (private)
++ setenv (priv_envvar, "true", 1);
++ else
++ unsetenv (priv_envvar);
++
++ set_enable_private_webkit (private);
++}
++
++static int
++get_enable_private () {
++ return get_enable_private_webkit ();
++}
++
++static void
+ set_proxy_url(const gchar *proxy_url) {
+ g_free(uzbl.net.proxy_url);
+ uzbl.net.proxy_url = g_strdup(proxy_url);
+@@ -459,28 +689,45 @@ set_proxy_url(const gchar *proxy_url) {
+ soup_uri_free(soup_uri);
+ }
+
+-void
+-set_authentication_handler(const gchar *handler) {
+- /* Check if WEBKIT_TYPE_SOUP_AUTH_DIALOG feature is set */
+- GSList *flist = soup_session_get_features (uzbl.net.soup_session, (GType) WEBKIT_TYPE_SOUP_AUTH_DIALOG);
+- guint feature_is_set = g_slist_length(flist);
+- g_slist_free(flist);
+-
+- g_free(uzbl.behave.authentication_handler);
+- uzbl.behave.authentication_handler = g_strdup(handler);
+-
+- if (uzbl.behave.authentication_handler == NULL || *uzbl.behave.authentication_handler == 0) {
+- if (!feature_is_set)
+- soup_session_add_feature_by_type
+- (uzbl.net.soup_session, (GType) WEBKIT_TYPE_SOUP_AUTH_DIALOG);
++/**
++ * Check if the webkit auth dialog is enabled for the soup session
++ */
++int
++get_enable_builtin_auth () {
++ SoupSessionFeature *auth = soup_session_get_feature (
++ uzbl.net.soup_session,
++ (GType) WEBKIT_TYPE_SOUP_AUTH_DIALOG
++ );
++
++ return auth != NULL;
++}
++
++/**
++ * Enable/Disable the webkit auth dialog for the soup session
++ */
++static void
++set_enable_builtin_auth (int enabled) {
++ SoupSessionFeature *auth = soup_session_get_feature (
++ uzbl.net.soup_session,
++ (GType) WEBKIT_TYPE_SOUP_AUTH_DIALOG
++ );
++
++ if (enabled > 0) {
++ if (auth == NULL) {
++ soup_session_add_feature_by_type (
++ uzbl.net.soup_session,
++ (GType) WEBKIT_TYPE_SOUP_AUTH_DIALOG
++ );
++ }
+ } else {
+- if (feature_is_set)
+- soup_session_remove_feature_by_type
+- (uzbl.net.soup_session, (GType) WEBKIT_TYPE_SOUP_AUTH_DIALOG);
++ if (auth != NULL) {
++ soup_session_remove_feature (uzbl.net.soup_session, auth);
++ }
+ }
++
+ }
+
+-void
++static void
+ set_status_background(const gchar *background) {
+ /* labels and hboxes do not draw their own background. applying this
+ * on the vbox/main_window is ok as the statusbar is the only affected
+@@ -501,7 +748,7 @@ set_status_background(const gchar *background) {
+ #endif
+ }
+
+-void
++static void
+ set_icon(const gchar *icon) {
+ if(file_exists(icon) && uzbl.gui.main_window) {
+ g_free(uzbl.gui.icon);
+@@ -513,7 +760,7 @@ set_icon(const gchar *icon) {
+ }
+ }
+
+-void
++static void
+ set_window_role(const gchar *role) {
+ if (!uzbl.gui.main_window)
+ return;
+@@ -521,7 +768,7 @@ set_window_role(const gchar *role) {
+ gtk_window_set_role(GTK_WINDOW (uzbl.gui.main_window), role);
+ }
+
+-gchar *
++static gchar *
+ get_window_role() {
+ if (!uzbl.gui.main_window)
+ return NULL;
+@@ -585,7 +832,7 @@ get_show_status() {
+ return gtk_widget_get_visible(uzbl.gui.status_bar);
+ }
+
+-void
++static void
+ set_status_top(int status_top) {
+ if (!uzbl.gui.scrolled_win && !uzbl.gui.status_bar)
+ return;
+@@ -612,21 +859,27 @@ set_status_top(int status_top) {
+ gtk_widget_grab_focus (GTK_WIDGET (uzbl.gui.web_view));
+ }
+
+-void
+-set_current_encoding(const gchar *encoding) {
++static void
++set_custom_encoding(const gchar *encoding) {
+ if(strlen(encoding) == 0)
+ encoding = NULL;
+
+ webkit_web_view_set_custom_encoding(uzbl.gui.web_view, encoding);
+ }
+
+-gchar *
+-get_current_encoding() {
++static gchar *
++get_custom_encoding() {
+ const gchar *encoding = webkit_web_view_get_custom_encoding(uzbl.gui.web_view);
+ return g_strdup(encoding);
+ }
+
+-void
++static gchar *
++get_current_encoding() {
++ const gchar *encoding = webkit_web_view_get_encoding (uzbl.gui.web_view);
++ return g_strdup(encoding);
++}
++
++static void
+ set_fifo_dir(const gchar *fifo_dir) {
+ g_free(uzbl.behave.fifo_dir);
+
+@@ -636,7 +889,7 @@ set_fifo_dir(const gchar *fifo_dir) {
+ uzbl.behave.fifo_dir = NULL;
+ }
+
+-void
++static void
+ set_socket_dir(const gchar *socket_dir) {
+ g_free(uzbl.behave.socket_dir);
+
+@@ -646,26 +899,38 @@ set_socket_dir(const gchar *socket_dir) {
+ uzbl.behave.socket_dir = NULL;
+ }
+
+-void
++#ifdef USE_WEBKIT2
++static void
++set_inject_text(const gchar *text) {
++ webkit_web_view_load_plain_text (uzbl.gui.web_view, html, NULL);
++}
++#endif
++
++static void
+ set_inject_html(const gchar *html) {
++#ifdef USE_WEBKIT2
++ webkit_web_view_load_html (uzbl.gui.web_view, html, NULL);
++#else
+ webkit_web_view_load_html_string (uzbl.gui.web_view, html, NULL);
++#endif
+ }
+
+-void
++static void
+ set_useragent(const gchar *useragent) {
+ g_free(uzbl.net.useragent);
+
+- if (*useragent == ' ') {
++ if (!useragent || !*useragent) {
+ uzbl.net.useragent = NULL;
+ } else {
+ uzbl.net.useragent = g_strdup(useragent);
+
+ g_object_set(G_OBJECT(uzbl.net.soup_session), SOUP_SESSION_USER_AGENT,
+ uzbl.net.useragent, NULL);
++ g_object_set(view_settings(), "user-agent", uzbl.net.useragent, NULL);
+ }
+ }
+
+-void
++static void
+ set_accept_languages(const gchar *accept_languages) {
+ g_free(uzbl.net.accept_languages);
+
+@@ -679,8 +944,7 @@ set_accept_languages(const gchar *accept_languages) {
+ }
+ }
+
+-/* requires webkit >=1.1.14 */
+-void
++static void
+ set_view_source(int view_source) {
+ uzbl.behave.view_source = view_source;
+
+@@ -688,6 +952,7 @@ set_view_source(int view_source) {
+ (gboolean) uzbl.behave.view_source);
+ }
+
++#ifndef USE_WEBKIT2
+ void
+ set_zoom_type (int type) {
+ webkit_web_view_set_full_content_zoom (uzbl.gui.web_view, type);
+@@ -697,17 +962,207 @@ int
+ get_zoom_type () {
+ return webkit_web_view_get_full_content_zoom (uzbl.gui.web_view);
+ }
++#endif
+
+-void
++static void
+ set_zoom_level(float zoom_level) {
+ webkit_web_view_set_zoom_level (uzbl.gui.web_view, zoom_level);
+ }
+
+-float
++static float
+ get_zoom_level() {
+ return webkit_web_view_get_zoom_level (uzbl.gui.web_view);
+ }
+
++static gchar *
++get_cache_model() {
++ WebKitCacheModel model = webkit_get_cache_model ();
++
++ switch (model) {
++ case WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER:
++ return g_strdup("document_viewer");
++ case WEBKIT_CACHE_MODEL_WEB_BROWSER:
++ return g_strdup("web_browser");
++ case WEBKIT_CACHE_MODEL_DOCUMENT_BROWSER:
++ return g_strdup("document_browser");
++ default:
++ return g_strdup("unknown");
++ }
++}
++
++static void
++set_cache_model(const gchar *model) {
++ if (!g_strcmp0 (model, "default")) {
++ webkit_set_cache_model (WEBKIT_CACHE_MODEL_DEFAULT);
++ } else if (!g_strcmp0 (model, "document_viewer")) {
++ webkit_set_cache_model (WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER);
++ } else if (!g_strcmp0 (model, "web_browser")) {
++ webkit_set_cache_model (WEBKIT_CACHE_MODEL_WEB_BROWSER);
++ } else if (!g_strcmp0 (model, "document_browser")) {
++ webkit_set_cache_model (WEBKIT_CACHE_MODEL_DOCUMENT_BROWSER);
++ }
++}
++
++static gchar *
++get_web_database_directory() {
++ return g_strdup (webkit_get_web_database_directory_path ());
++}
++
++static unsigned long long
++get_web_database_quota () {
++ return webkit_get_default_web_database_quota ();
++}
++
++static void
++set_web_database_quota (unsigned long long quota) {
++ webkit_set_default_web_database_quota (quota);
++}
++
++static void
++set_web_database_directory(const gchar *path) {
++ webkit_set_web_database_directory_path (path);
++}
++
++#if WEBKIT_CHECK_VERSION (1, 3, 4)
++static gchar *
++get_view_mode() {
++ WebKitWebViewViewMode mode = webkit_web_view_get_view_mode (uzbl.gui.web_view);
++
++ switch (mode) {
++ case WEBKIT_WEB_VIEW_VIEW_MODE_WINDOWED:
++ return g_strdup("windowed");
++ case WEBKIT_WEB_VIEW_VIEW_MODE_FLOATING:
++ return g_strdup("floating");
++ case WEBKIT_WEB_VIEW_VIEW_MODE_FULLSCREEN:
++ return g_strdup("fullscreen");
++ case WEBKIT_WEB_VIEW_VIEW_MODE_MAXIMIZED:
++ return g_strdup("maximized");
++ case WEBKIT_WEB_VIEW_VIEW_MODE_MINIMIZED:
++ return g_strdup("minimized");
++ default:
++ return g_strdup("unknown");
++ }
++}
++
++static void
++set_view_mode(const gchar *mode) {
++ if (!g_strcmp0 (mode, "windowed")) {
++ webkit_web_view_set_view_mode (uzbl.gui.web_view, WEBKIT_WEB_VIEW_VIEW_MODE_WINDOWED);
++ } else if (!g_strcmp0 (mode, "floating")) {
++ webkit_web_view_set_view_mode (uzbl.gui.web_view, WEBKIT_WEB_VIEW_VIEW_MODE_FLOATING);
++ } else if (!g_strcmp0 (mode, "fullscreen")) {
++ webkit_web_view_set_view_mode (uzbl.gui.web_view, WEBKIT_WEB_VIEW_VIEW_MODE_FULLSCREEN);
++ } else if (!g_strcmp0 (mode, "maximized")) {
++ webkit_web_view_set_view_mode (uzbl.gui.web_view, WEBKIT_WEB_VIEW_VIEW_MODE_MAXIMIZED);
++ } else if (!g_strcmp0 (mode, "minimized")) {
++ webkit_web_view_set_view_mode (uzbl.gui.web_view, WEBKIT_WEB_VIEW_VIEW_MODE_MINIMIZED);
++ }
++}
++#endif
++
++#if WEBKIT_CHECK_VERSION (1, 3, 17)
++static gchar *
++get_inspected_uri() {
++ return g_strdup (webkit_web_inspector_get_inspected_uri (uzbl.gui.inspector));
++}
++#endif
++
++#if WEBKIT_CHECK_VERSION (1, 3, 13)
++static gchar *
++get_app_cache_directory() {
++ return g_strdup (webkit_application_cache_get_database_directory_path ());
++}
++
++static unsigned long long
++get_app_cache_size() {
++ return webkit_application_cache_get_maximum_size ();
++}
++
++static void
++set_app_cache_size(unsigned long long size) {
++ webkit_application_cache_set_maximum_size (size);
++}
++#endif
++
++#if WEBKIT_CHECK_VERSION (1, 3, 8)
++static void
++mimetype_list_append(WebKitWebPluginMIMEType *mimetype, GString *list) {
++ if (*list->str != '[') {
++ g_string_append_c (list, ',');
++ }
++
++ /* Write out a JSON representation of the information */
++ g_string_append_printf (list,
++ "{\"name\": \"%s\","
++ "\"description\": \"%s\","
++ "\"extensions\": [", /* Open array for the extensions */
++ mimetype->name,
++ mimetype->description);
++
++ char **extension = mimetype->extensions;
++ gboolean first = TRUE;
++
++ while (extension) {
++ if (first) {
++ first = FALSE;
++ } else {
++ g_string_append_c (list, ',');
++ }
++ g_string_append (list, *extension);
++
++ ++extension;
++ }
++
++ g_string_append_c (list, '}');
++}
++
++static void
++plugin_list_append(WebKitWebPlugin *plugin, GString *list) {
++ if (*list->str != '[') {
++ g_string_append_c (list, ',');
++ }
++
++ const gchar *desc = webkit_web_plugin_get_description (plugin);
++ gboolean enabled = webkit_web_plugin_get_enabled (plugin);
++ GSList *mimetypes = webkit_web_plugin_get_mimetypes (plugin);
++ const gchar *name = webkit_web_plugin_get_name (plugin);
++ const gchar *path = webkit_web_plugin_get_path (plugin);
++
++ /* Write out a JSON representation of the information */
++ g_string_append_printf (list,
++ "{\"name\": \"%s\","
++ "\"description\": \"%s\","
++ "\"enabled\": %s,"
++ "\"path\": \"%s\","
++ "\"mimetypes\": [", /* Open array for the mimetypes */
++ name,
++ desc,
++ enabled ? "true" : "false",
++ path);
++
++ g_slist_foreach (mimetypes, (GFunc)mimetype_list_append, list);
++
++ /* Close the array and the object */
++ g_string_append (list, "]}");
++}
++
++static gchar *
++get_plugin_list() {
++ WebKitWebPluginDatabase *db = webkit_get_web_plugin_database ();
++ GSList *plugins = webkit_web_plugin_database_get_plugins (db);
++
++ GString *list = g_string_new ("[");
++
++ g_slist_foreach (plugins, (GFunc)plugin_list_append, list);
++
++ g_string_append_c (list, ']');
++
++ webkit_web_plugin_database_plugins_list_free (plugins);
++
++ return g_string_free (list, FALSE);
++}
++#endif
++
+ /* abbreviations to help keep the table's width humane */
+
+ /* variables */
+@@ -717,6 +1172,7 @@ get_zoom_level() {
+
+ #define PTR_V_STR_GETSET(var) { .type = TYPE_STR, .dump = 1, .writeable = 1, .getter = (uzbl_fp) get_##var, .setter = (uzbl_fp)set_##var }
+ #define PTR_V_INT_GETSET(var) { .type = TYPE_INT, .dump = 1, .writeable = 1, .getter = (uzbl_fp) get_##var, .setter = (uzbl_fp)set_##var }
++#define PTR_V_ULL_GETSET(var) { .type = TYPE_ULL, .dump = 1, .writeable = 1, .getter = (uzbl_fp) get_##var, .setter = (uzbl_fp)set_##var }
+ #define PTR_V_FLOAT_GETSET(var) { .type = TYPE_FLOAT, .dump = 1, .writeable = 1, .getter = (uzbl_fp) get_##var, .setter = (uzbl_fp)set_##var }
+
+ /* constants */
+@@ -724,6 +1180,11 @@ get_zoom_level() {
+ #define PTR_C_INT(var) { .ptr = { .i = (int*)&(var) }, .type = TYPE_INT, .dump = 0, .writeable = 0, .getter = NULL, .setter = NULL }
+ #define PTR_C_FLOAT(var) { .ptr = { .f = &(var) }, .type = TYPE_FLOAT, .dump = 0, .writeable = 0, .getter = NULL, .setter = NULL }
+
++/* programmatic constants */
++#define PTR_C_STR_F(get) { .type = TYPE_STR, .dump = 0, .writeable = 0, .getter = (uzbl_fp)get, .setter = NULL }
++#define PTR_C_INT_F(get) { .type = TYPE_INT, .dump = 0, .writeable = 0, .getter = (uzbl_fp)get, .setter = NULL }
++#define PTR_C_FLOAT_F(get) { .type = TYPE_FLOAT, .dump = 0, .writeable = 0, .getter = (uzbl_fp)get, .setter = NULL }
++
+ const struct var_name_to_ptr_t {
+ const char *name;
+ uzbl_cmdprop cp;
+@@ -751,7 +1212,6 @@ const struct var_name_to_ptr_t {
+
+ { "forward_keys", PTR_V_INT(uzbl.behave.forward_keys, 1, NULL)},
+
+- { "authentication_handler", PTR_V_STR(uzbl.behave.authentication_handler, 1, set_authentication_handler)},
+ { "scheme_handler", PTR_V_STR(uzbl.behave.scheme_handler, 1, NULL)},
+ { "request_handler", PTR_V_STR(uzbl.behave.request_handler, 1, NULL)},
+ { "download_handler", PTR_V_STR(uzbl.behave.download_handler, 1, NULL)},
+@@ -773,45 +1233,145 @@ const struct var_name_to_ptr_t {
+ { "ssl_ca_file", PTR_V_STR_GETSET(ca_file)},
+ { "ssl_verify", PTR_V_INT_GETSET(verify_cert)},
+
+- /* exported WebKitWebSettings properties */
+- { "javascript_windows", PTR_V_INT_GETSET(javascript_windows)},
+- { "zoom_level", PTR_V_FLOAT_GETSET(zoom_level)},
+- { "zoom_type", PTR_V_INT_GETSET(zoom_type)},
++ { "enable_builtin_auth", PTR_V_INT_GETSET(enable_builtin_auth)},
++ { "cache_model", PTR_V_STR_GETSET(cache_model)},
++#if WEBKIT_CHECK_VERSION (1, 3, 13)
++ { "app_cache_size", PTR_V_ULL_GETSET(app_cache_size)},
++#endif
++ { "web_database_directory", PTR_V_STR_GETSET(web_database_directory)},
++ { "web_database_quota", PTR_V_ULL_GETSET(web_database_quota)},
+
++ /* exported WebKitWebSettings properties */
++ /* Font settings */
+ { "default_font_family", PTR_V_STR_GETSET(default_font_family)},
+ { "monospace_font_family", PTR_V_STR_GETSET(monospace_font_family)},
+- { "cursive_font_family", PTR_V_STR_GETSET(cursive_font_family)},
+ { "sans_serif_font_family", PTR_V_STR_GETSET(sans_serif_font_family)},
+ { "serif_font_family", PTR_V_STR_GETSET(serif_font_family)},
++ { "cursive_font_family", PTR_V_STR_GETSET(cursive_font_family)},
+ { "fantasy_font_family", PTR_V_STR_GETSET(fantasy_font_family)},
+-
+- { "monospace_size", PTR_V_INT_GETSET(monospace_size)},
+- { "font_size", PTR_V_INT_GETSET(font_size)},
++ /* Font size settings */
+ { "minimum_font_size", PTR_V_INT_GETSET(minimum_font_size)},
+-
+- { "enable_pagecache", PTR_V_INT_GETSET(enable_pagecache)},
++ { "font_size", PTR_V_INT_GETSET(font_size)},
++ { "monospace_size", PTR_V_INT_GETSET(monospace_size)},
++ /* Text settings */
++ { "default_encoding", PTR_V_STR_GETSET(default_encoding)},
++ { "custom_encoding", PTR_V_STR_GETSET(custom_encoding)},
++ { "enforce_96_dpi", PTR_V_INT_GETSET(enforce_96_dpi)},
++ { "editable", PTR_V_INT_GETSET(editable)},
++ /* Feature settings */
+ { "enable_plugins", PTR_V_INT_GETSET(enable_plugins)},
++ { "enable_java_applet", PTR_V_INT_GETSET(enable_java_applet)},
++#if WEBKIT_CHECK_VERSION (1, 3, 14)
++ { "enable_webgl", PTR_V_INT_GETSET(enable_webgl)},
++#endif
++#if WEBKIT_CHECK_VERSION (1, 7, 5)
++ { "enable_webaudio", PTR_V_INT_GETSET(enable_webaudio)},
++#endif
++#if WEBKIT_CHECK_VERSION (1, 7, 90) /* Documentation says 1.7.5, but it's not there. */
++ { "enable_3d_acceleration", PTR_V_INT_GETSET(enable_3d_acceleration)},
++#endif
++#if WEBKIT_CHECK_VERSION (1, 11, 1)
++ { "enable_css_shaders", PTR_V_INT_GETSET(enable_css_shaders)},
++#endif
++ /* HTML5 Database settings */
++ { "enable_database", PTR_V_INT_GETSET(enable_database)},
++ { "enable_local_storage", PTR_V_INT_GETSET(enable_local_storage)},
++ { "enable_pagecache", PTR_V_INT_GETSET(enable_pagecache)},
++ { "enable_offline_app_cache", PTR_V_INT_GETSET(enable_offline_app_cache)},
++#if WEBKIT_CHECK_VERSION (1, 5, 2)
++ { "local_storage_path", PTR_V_STR_GETSET(local_storage_path)},
++#endif
++ /* Security settings */
++ { "enable_private", PTR_V_INT_GETSET(enable_private)},
++ { "enable_universal_file_access", PTR_V_INT_GETSET(enable_universal_file_access)},
++ { "enable_cross_file_access", PTR_V_INT_GETSET(enable_cross_file_access)},
++ { "enable_hyperlink_auditing", PTR_V_INT_GETSET(enable_hyperlink_auditing)},
++ { "cookie_policy", PTR_V_INT_GETSET(cookie_policy)},
++#if WEBKIT_CHECK_VERSION (1, 3, 13)
++ { "enable_dns_prefetch", PTR_V_INT_GETSET(enable_dns_prefetch)},
++#endif
++#if WEBKIT_CHECK_VERSION (1, 11, 2)
++ { "display_insecure_content",PTR_V_INT_GETSET(display_insecure_content)},
++ { "run_insecure_content", PTR_V_INT_GETSET(run_insecure_content)},
++#endif
++ { "maintain_history", PTR_V_INT_GETSET(maintain_history)},
++ /* Display settings */
++ { "transparent", PTR_V_STR_GETSET(transparent)},
++#if WEBKIT_CHECK_VERSION (1, 3, 4)
++ { "view_mode", PTR_V_STR_GETSET(view_mode)},
++#endif
++ { "zoom_level", PTR_V_FLOAT_GETSET(zoom_level)},
++ { "zoom_step", PTR_V_FLOAT_GETSET(zoom_step)},
++#ifndef USE_WEBKIT2
++ { "zoom_type", PTR_V_INT_GETSET(zoom_type)},
++#endif
++ { "caret_browsing", PTR_V_INT_GETSET(caret_browsing)},
++ { "auto_resize_window", PTR_V_INT_GETSET(auto_resize_window)},
++#if WEBKIT_CHECK_VERSION (1, 3, 5)
++ { "enable_frame_flattening", PTR_V_INT_GETSET(enable_frame_flattening)},
++#endif
++#if WEBKIT_CHECK_VERSION (1, 3, 8)
++ { "enable_fullscreen", PTR_V_INT_GETSET(enable_fullscreen)},
++#endif
++#ifdef USE_WEBKIT2
++#if WEBKIT_CHECK_VERSION (1, 7, 91)
++ { "zoom_text_only", PTR_V_INT_GETSET(zoom_text_only)},
++#endif
++#endif
++#if WEBKIT_CHECK_VERSION (1, 9, 0)
++ { "enable_smooth_scrolling",PTR_V_INT_GETSET(enable_smooth_scrolling)},
++#endif
++ /* Javascript settings */
+ { "enable_scripts", PTR_V_INT_GETSET(enable_scripts)},
++ { "javascript_windows", PTR_V_INT_GETSET(javascript_windows)},
++ { "javascript_dom_paste", PTR_V_INT_GETSET(javascript_dom_paste)},
++#if WEBKIT_CHECK_VERSION (1, 3, 0)
++ { "javascript_clipboard", PTR_V_INT_GETSET(javascript_clipboard)},
++#endif
++ /* Media settings */
++#if WEBKIT_CHECK_VERSION (1, 9, 3)
++ { "enable_inline_media", PTR_V_INT_GETSET(enable_inline_media)},
++ { "require_click_to_play", PTR_V_INT_GETSET(require_click_to_play)},
++#endif
++#if WEBKIT_CHECK_VERSION (1, 11, 1)
++ { "enable_media_stream", PTR_V_INT_GETSET(enable_media_stream)},
++#endif
++ /* Image settings */
+ { "autoload_images", PTR_V_INT_GETSET(autoload_images)},
+ { "autoshrink_images", PTR_V_INT_GETSET(autoshrink_images)},
++ /* Spell checking settings */
+ { "enable_spellcheck", PTR_V_INT_GETSET(enable_spellcheck)},
+ { "spellcheck_languages", PTR_V_STR_GETSET(spellcheck_languages)},
+- { "enable_private", PTR_V_INT_GETSET(enable_private)},
+- { "print_backgrounds", PTR_V_INT_GETSET(print_bg)},
+- { "stylesheet_uri", PTR_V_STR_GETSET(stylesheet_uri)},
++ /* Form settings */
+ { "resizable_text_areas", PTR_V_INT_GETSET(resizable_text_areas)},
+- { "default_encoding", PTR_V_STR_GETSET(default_encoding)},
+- { "current_encoding", PTR_V_STR_GETSET(current_encoding)},
+- { "enforce_96_dpi", PTR_V_INT_GETSET(enforce_96_dpi)},
+- { "caret_browsing", PTR_V_INT_GETSET(caret_browsing)},
+- { "enable_cross_file_access", PTR_V_INT_GETSET(enable_cross_file_access)},
++ { "enable_spatial_navigation", PTR_V_INT_GETSET(enable_spatial_navigation)},
++ { "editing_behavior", PTR_V_INT_GETSET(editing_behavior)},
++ { "enable_tab_cycle", PTR_V_INT_GETSET(enable_tab_cycle)},
++ /* Customization */
++ { "stylesheet_uri", PTR_V_STR_GETSET(stylesheet_uri)},
++#if WEBKIT_CHECK_VERSION (1, 9, 0)
++ { "default_context_menu", PTR_V_INT(uzbl.gui.custom_context_menu, 1, NULL)},
++#else
++ { "default_context_menu", PTR_V_INT_GETSET(default_context_menu)},
++#endif
++ /* Hacks */
++ { "enable_site_workarounds", PTR_V_INT_GETSET(enable_site_workarounds)},
++ /* Printing settings */
++ { "print_backgrounds", PTR_V_INT_GETSET(print_bg)},
++ /* Inspector settings */
++ { "profile_js", PTR_V_INT_GETSET(profile_js)},
++ { "profile_timeline", PTR_V_INT_GETSET(profile_timeline)},
+
++#ifdef USE_WEBKIT2
++ { "inject_text", { .type = TYPE_STR, .dump = 0, .writeable = 1, .getter = NULL, .setter = (uzbl_fp) set_inject_text }},
++#endif
+ { "inject_html", { .type = TYPE_STR, .dump = 0, .writeable = 1, .getter = NULL, .setter = (uzbl_fp) set_inject_html }},
+
+ /* constants (not dumpable or writeable) */
+ { "WEBKIT_MAJOR", PTR_C_INT(uzbl.info.webkit_major)},
+ { "WEBKIT_MINOR", PTR_C_INT(uzbl.info.webkit_minor)},
+ { "WEBKIT_MICRO", PTR_C_INT(uzbl.info.webkit_micro)},
++ { "HAS_WEBKIT2", PTR_C_INT(uzbl.info.webkit2)},
+ { "ARCH_UZBL", PTR_C_STR(uzbl.info.arch)},
+ { "COMMIT", PTR_C_STR(uzbl.info.commit)},
+ { "TITLE", PTR_C_STR(uzbl.gui.main_title)},
+@@ -820,6 +1380,18 @@ const struct var_name_to_ptr_t {
+ { "PID", PTR_C_STR(uzbl.info.pid_str)},
+ { "_", PTR_C_STR(uzbl.state.last_result)},
+
++ /* runtime settings */
++ { "current_encoding", PTR_C_STR_F(get_current_encoding)},
++#if WEBKIT_CHECK_VERSION (1, 3, 17)
++ { "inspected_uri", PTR_C_STR_F(get_inspected_uri)},
++#endif
++#if WEBKIT_CHECK_VERSION (1, 3, 13)
++ { "app_cache_directory", PTR_C_STR_F(get_app_cache_directory)},
++#endif
++#if WEBKIT_CHECK_VERSION (1, 3, 8)
++ { "plugin_list", PTR_C_STR_F(get_plugin_list)},
++#endif
++
+ /* and we terminate the whole thing with the closest thing we have to NULL.
+ * it's important that dump = 0. */
+ { NULL, {.ptr = { .i = NULL }, .type = TYPE_INT, .dump = 0, .writeable = 0}}
+diff --git a/src/variables.h b/src/variables.h
+index dade652..0b935eb 100644
+--- a/src/variables.h
++++ b/src/variables.h
+@@ -6,7 +6,11 @@
+ #define __VARIABLES__
+
+ #include <glib.h>
++#ifdef USE_WEBKIT2
++#include <webkit2/webkit2.h>
++#else
+ #include <webkit/webkit.h>
++#endif
+
+ #include "type.h"
+
+@@ -20,11 +24,14 @@ gchar *get_var_value_string_c(const uzbl_cmdprop *c);
+ gchar *get_var_value_string(const char *name);
+ int get_var_value_int_c(const uzbl_cmdprop *c);
+ int get_var_value_int(const char *name);
++unsigned long long get_var_value_ull_c(const uzbl_cmdprop *c);
++unsigned long long get_var_value_ull(const char *name);
+ float get_var_value_float_c(const uzbl_cmdprop *c);
+ float get_var_value_float(const char *name);
+
+ void set_var_value_string_c(uzbl_cmdprop *c, const gchar *val);
+-void set_var_value_int_c(uzbl_cmdprop *c, int f);
++void set_var_value_int_c(uzbl_cmdprop *c, int i);
++void set_var_value_ull_c(uzbl_cmdprop *c, unsigned long long ull);
+ void set_var_value_float_c(uzbl_cmdprop *c, float f);
+
+ void send_set_var_event(const char *name, const uzbl_cmdprop *c);
+@@ -34,8 +41,6 @@ void dump_config_as_events();
+
+ void uri_change_cb (WebKitWebView *web_view, GParamSpec param_spec);
+
+-void set_show_status(int);
+-
+ void set_zoom_type(int);
+ int get_zoom_type();
+
+diff --git a/tests/event-manager/emtest.py b/tests/event-manager/emtest.py
+new file mode 100644
+index 0000000..27ce21b
+--- /dev/null
++++ b/tests/event-manager/emtest.py
+@@ -0,0 +1,30 @@
++from mock import Mock
++import logging
++from uzbl.event_manager import Uzbl
++
++
++class EventManagerMock(object):
++ def __init__(self,
++ global_plugins=(), instance_plugins=(),
++ global_mock_plugins=(), instance_mock_plugins=()
++ ):
++ self.uzbls = {}
++ self.plugins = {}
++ self.instance_plugins = instance_plugins
++ self.instance_mock_plugins = instance_mock_plugins
++ for plugin in global_plugins:
++ self.plugins[plugin] = plugin(self)
++ for (plugin, mock) in global_mock_plugins:
++ self.plugins[plugin] = mock() if mock else Mock(plugin)
++
++ def add(self):
++ u = Mock(spec=Uzbl)
++ u.parent = self
++ u.logger = logging.getLogger('debug')
++ u.plugins = {}
++ for plugin in self.instance_plugins:
++ u.plugins[plugin] = plugin(u)
++ for (plugin, mock) in self.instance_mock_plugins:
++ u.plugins[plugin] = mock() if mock else Mock(plugin)
++ self.uzbls[Mock()] = u
++ return u
+diff --git a/tests/event-manager/testarguments.py b/tests/event-manager/testarguments.py
+new file mode 100755
+index 0000000..edb102d
+--- /dev/null
++++ b/tests/event-manager/testarguments.py
+@@ -0,0 +1,25 @@
++#!/usr/bin/env python
++
++import unittest
++from uzbl.arguments import Arguments
++
++
++class ArgumentsTest(unittest.TestCase):
++ def test_empty(self):
++ a = Arguments('')
++ self.assertEqual(len(a), 0)
++ self.assertEqual(a.raw(), '')
++
++ def test_space(self):
++ a = Arguments(' foo bar')
++ self.assertEqual(len(a), 2)
++ self.assertEqual(a.raw(), 'foo bar')
++ self.assertEqual(a.raw(0, 0), 'foo')
++ self.assertEqual(a.raw(1, 1), 'bar')
++
++ def test_tab(self):
++ a = Arguments('\tfoo\t\tbar')
++ self.assertEqual(len(a), 2)
++ self.assertEqual(a.raw(), 'foo\t\tbar')
++ self.assertEqual(a.raw(0, 0), 'foo')
++ self.assertEqual(a.raw(1, 1), 'bar')
+diff --git a/tests/event-manager/testbind.py b/tests/event-manager/testbind.py
+new file mode 100644
+index 0000000..a2e8d70
+--- /dev/null
++++ b/tests/event-manager/testbind.py
+@@ -0,0 +1,51 @@
++#!/usr/bin/env python
++
++
++import sys
++if '' not in sys.path:
++ sys.path.insert(0, '')
++
++import mock
++import unittest
++from emtest import EventManagerMock
++from uzbl.plugins.bind import Bind, BindPlugin
++from uzbl.plugins.config import Config
++
++
++def justafunction():
++ pass
++
++
++class BindTest(unittest.TestCase):
++ def test_unique_id(self):
++ a = Bind('spam', 'spam')
++ b = Bind('spam', 'spam')
++ self.assertNotEqual(a.bid, b.bid)
++
++
++class BindPluginTest(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock((), (Config, BindPlugin))
++ self.uzbl = self.event_manager.add()
++
++ def test_add_bind(self):
++ b = BindPlugin[self.uzbl]
++ modes = 'global'
++ glob = 'test'
++ handler = justafunction
++ b.mode_bind(modes, glob, handler)
++
++ binds = b.bindlet.get_binds()
++ self.assertEqual(len(binds), 1)
++ self.assertIs(binds[0].function, justafunction)
++
++ def test_parse_bind(self):
++ b = BindPlugin[self.uzbl]
++ modes = 'global'
++ glob = 'test'
++ handler = 'handler'
++
++ b.parse_mode_bind('%s %s = %s' % (modes, glob, handler))
++ binds = b.bindlet.get_binds()
++ self.assertEqual(len(binds), 1)
++ self.assertEqual(binds[0].commands, [handler])
+diff --git a/tests/event-manager/testcompletion.py b/tests/event-manager/testcompletion.py
+new file mode 100644
+index 0000000..8ae32a2
+--- /dev/null
++++ b/tests/event-manager/testcompletion.py
+@@ -0,0 +1,118 @@
++#!/usr/bin/env python
++# vi: set et ts=4:
++
++
++
++import unittest
++from emtest import EventManagerMock
++from uzbl.plugins.config import Config
++from uzbl.plugins.keycmd import KeyCmd
++from uzbl.plugins.completion import CompletionPlugin
++
++
++class DummyFormatter(object):
++ def format(self, partial, completions):
++ return '[%s] %s' % (partial, ', '.join(completions))
++
++class TestAdd(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock(
++ (), (CompletionPlugin,),
++ (), ((Config, dict), (KeyCmd, None))
++ )
++ self.uzbl = self.event_manager.add()
++
++ def test_builtins(self):
++ c = CompletionPlugin[self.uzbl]
++ c.add_builtins(('spam', 'egg'))
++ self.assertIn('spam', c.completion)
++ self.assertIn('egg', c.completion)
++
++ def test_config(self):
++ c = CompletionPlugin[self.uzbl]
++ c.add_config_key('spam', 'SPAM')
++ self.assertIn('@spam', c.completion)
++
++
++class TestCompletion(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock(
++ (), (KeyCmd, CompletionPlugin),
++ (), ((Config, dict),)
++ )
++ self.uzbl = self.event_manager.add()
++
++ c = CompletionPlugin[self.uzbl]
++ c.listformatter = DummyFormatter()
++ c.add_builtins(('spam', 'egg', 'bar', 'baz'))
++ c.add_config_key('spam', 'SPAM')
++ c.add_config_key('Something', 'Else')
++
++ def test_incomplete_keyword(self):
++ k, c = KeyCmd[self.uzbl], CompletionPlugin[self.uzbl]
++ k.keylet.keycmd = 'sp'
++ k.keylet.cursor = len(k.keylet.keycmd)
++
++ r = c.get_incomplete_keyword()
++ self.assertEqual(r, ('sp', False))
++
++ def test_incomplete_keyword_var(self):
++ k, c = KeyCmd[self.uzbl], CompletionPlugin[self.uzbl]
++ k.keylet.keycmd = 'set @sp'
++ k.keylet.cursor = len(k.keylet.keycmd)
++
++ r = c.get_incomplete_keyword()
++ self.assertEqual(r, ('@sp', False))
++
++ def test_incomplete_keyword_var_noat(self):
++ k, c = KeyCmd[self.uzbl], CompletionPlugin[self.uzbl]
++ k.keylet.keycmd = 'set Some'
++ k.keylet.cursor = len(k.keylet.keycmd)
++
++ r = c.get_incomplete_keyword()
++ self.assertEqual(r, ('@Some', True))
++
++ def test_stop_completion(self):
++ config, c = Config[self.uzbl], CompletionPlugin[self.uzbl]
++ c.completion.level = 99
++ config['completion_list'] = 'test'
++
++ c.stop_completion()
++ self.assertNotIn('completion_list', config)
++ self.assertEqual(c.completion.level, 0)
++
++ def test_completion(self):
++ k, c = KeyCmd[self.uzbl], CompletionPlugin[self.uzbl]
++ config = Config[self.uzbl]
++
++ comp = (
++ ('sp', 'spam '),
++ ('e', 'egg '),
++ ('set @sp', 'set @spam '),
++ )
++
++ for i, o in comp:
++ k.keylet.keycmd = i
++ k.keylet.cursor = len(k.keylet.keycmd)
++
++ c.start_completion()
++ self.assertEqual(k.keylet.keycmd, o)
++ c.start_completion()
++ self.assertNotIn('completion_list', config)
++
++ def test_completion_list(self):
++ k, c = KeyCmd[self.uzbl], CompletionPlugin[self.uzbl]
++ config = Config[self.uzbl]
++
++ comp = (
++ ('b', 'ba', '[ba] bar, baz'),
++ )
++
++ for i, o, l in comp:
++ k.keylet.keycmd = i
++ k.keylet.cursor = len(k.keylet.keycmd)
++
++ c.start_completion()
++ self.assertEqual(k.keylet.keycmd, o)
++ c.start_completion()
++ self.assertEqual(config['completion_list'], l)
+diff --git a/tests/event-manager/testconfig.py b/tests/event-manager/testconfig.py
+new file mode 100644
+index 0000000..d2a891e
+--- /dev/null
++++ b/tests/event-manager/testconfig.py
+@@ -0,0 +1,77 @@
++
++
++import unittest
++from emtest import EventManagerMock
++
++from uzbl.plugins.config import Config
++
++
++class ConfigTest(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock((), (Config,))
++ self.uzbl = self.event_manager.add()
++
++ def test_set(self):
++ cases = (
++ (True, '1'),
++ (False, '0'),
++ ("test", "test"),
++ (5, '5')
++ )
++ c = Config[self.uzbl]
++ for input, expected in cases:
++ c.set('foo', input)
++ self.uzbl.send.assert_called_once_with(
++ 'set foo = ' + expected)
++ self.uzbl.send.reset_mock()
++
++ def test_set_invalid(self):
++ cases = (
++ ("foo\nbar", AssertionError), # Better Exception type
++ ("bad'key", AssertionError)
++ )
++ c = Config[self.uzbl]
++ for input, exception in cases:
++ self.assertRaises(exception, c.set, input)
++
++ def test_parse(self):
++ cases = (
++ ('foo str value', 'foo', 'value'),
++ ('foo str "ba ba"', 'foo', 'ba ba'),
++ ('foo float 5', 'foo', 5.0)
++ )
++ c = Config[self.uzbl]
++ for input, ekey, evalue in cases:
++ c.parse_set_event(input)
++ self.assertIn(ekey, c)
++ self.assertEqual(c[ekey], evalue)
++ self.uzbl.event.assert_called_once_with(
++ 'CONFIG_CHANGED', ekey, evalue)
++ self.uzbl.event.reset_mock()
++
++ def test_parse_null(self):
++ cases = (
++ ('foo str', 'foo'),
++ ('foo str ""', 'foo'),
++ #('foo int', 'foo') # Not sure if this input is valid
++ )
++ c = Config[self.uzbl]
++ for input, ekey in cases:
++ c.update({'foo': '-'})
++ c.parse_set_event(input)
++ self.assertNotIn(ekey, c)
++ self.uzbl.event.assert_called_once_with(
++ 'CONFIG_CHANGED', ekey, '')
++ self.uzbl.event.reset_mock()
++
++ def test_parse_invalid(self):
++ cases = (
++ ('foo bar', AssertionError), # TypeError?
++ ('foo bad^key', AssertionError),
++ ('', Exception),
++ ('foo int z', ValueError)
++ )
++ c = Config[self.uzbl]
++ for input, exception in cases:
++ self.assertRaises(exception, c.parse_set_event, input)
++ self.assertEqual(len(list(c.keys())), 0)
+diff --git a/tests/event-manager/testcookie.py b/tests/event-manager/testcookie.py
+new file mode 100755
+index 0000000..c33ba3b
+--- /dev/null
++++ b/tests/event-manager/testcookie.py
+@@ -0,0 +1,67 @@
++#!/usr/bin/env python
++
++
++import sys
++if '' not in sys.path:
++ sys.path.insert(0, '')
++
++import unittest
++from emtest import EventManagerMock
++
++from uzbl.plugins.cookies import Cookies
++
++cookies = (
++ r'".nyan.cat" "/" "__utmb" "183192761.1.10.1313990640" "http" "1313992440"',
++ r'".twitter.com" "/" "guest_id" "v1%3A131399064036991891" "http" "1377104460"'
++)
++
++
++class CookieFilterTest(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock((), (Cookies,))
++ self.uzbl = self.event_manager.add()
++ self.other = self.event_manager.add()
++
++ def test_add_cookie(self):
++ c = Cookies[self.uzbl]
++ c.add_cookie(cookies[0])
++ self.other.send.assert_called_once_with(
++ 'add_cookie ' + cookies[0])
++
++ def test_whitelist_block(self):
++ c = Cookies[self.uzbl]
++ c.whitelist_cookie(r'domain "nyan\.cat$"')
++ c.add_cookie(cookies[1])
++ self.uzbl.send.assert_called_once_with(
++ 'delete_cookie ' + cookies[1])
++
++ def test_whitelist_accept(self):
++ c = Cookies[self.uzbl]
++ c.whitelist_cookie(r'domain "nyan\.cat$"')
++ c.add_cookie(cookies[0])
++ self.other.send.assert_called_once_with(
++ 'add_cookie ' + cookies[0])
++
++ def test_blacklist_block(self):
++ c = Cookies[self.uzbl]
++ c.blacklist_cookie(r'domain "twitter\.com$"')
++ c.add_cookie(cookies[1])
++ self.uzbl.send.assert_called_once_with(
++ 'delete_cookie ' + cookies[1])
++
++ def test_blacklist_accept(self):
++ c = Cookies[self.uzbl]
++ c.blacklist_cookie(r'domain "twitter\.com$"')
++ c.add_cookie(cookies[0])
++ self.other.send.assert_called_once_with(
++ 'add_cookie ' + cookies[0])
++
++ def test_filter_numeric(self):
++ c = Cookies[self.uzbl]
++ c.blacklist_cookie(r'0 "twitter\.com$"')
++ c.add_cookie(cookies[1])
++ self.uzbl.send.assert_called_once_with(
++ 'delete_cookie ' + cookies[1])
++
++if __name__ == '__main__':
++ unittest.main()
+diff --git a/tests/event-manager/testcore.py b/tests/event-manager/testcore.py
+new file mode 100644
+index 0000000..1a8b4fa
+--- /dev/null
++++ b/tests/event-manager/testcore.py
+@@ -0,0 +1,90 @@
++#!/usr/bin/env python
++# vi: set et ts=4:
++
++
++
++import unittest
++from mock import Mock
++from uzbl.core import Uzbl
++
++
++class TestUzbl(unittest.TestCase):
++ def setUp(self):
++ options = Mock()
++ options.print_events = False
++ self.em = Mock()
++ self.proto = Mock()
++ self.uzbl = Uzbl(self.em, self.proto, options)
++
++ def test_repr(self):
++ r = '%r' % self.uzbl
++ self.assertRegex(r, r'<uzbl\(.*\)>')
++
++ def test_event_handler(self):
++ handler = Mock()
++ event, arg = 'FOO', 'test'
++ self.uzbl.connect(event, handler)
++ self.uzbl.event(event, arg)
++ handler.assert_called_once_with(arg)
++
++ def test_parse_sets_name(self):
++ name = 'spam'
++ self.uzbl.parse_msg(' '.join(['EVENT', name, 'FOO', 'BAR']))
++ self.assertEqual(self.uzbl.name, name)
++
++ def test_parse_sends_event(self):
++ handler = Mock()
++ event, arg = 'FOO', 'test'
++ self.uzbl.connect(event, handler)
++ self.uzbl.parse_msg(' '.join(['EVENT', 'instance-name', event, arg]))
++ handler.assert_called_once_with(arg)
++
++ def test_malformed_message(self):
++ # Should not crash
++ self.uzbl.parse_msg('asdaf')
++ self.assertTrue(True)
++
++ def test_send(self):
++ self.uzbl.send('hello ')
++ self.proto.push.assert_called_once_with('hello\n'.encode('utf-8'))
++
++ def test_close_calls_remove_instance(self):
++ self.uzbl.close()
++ self.em.remove_instance.assert_called_once_with(self.proto.socket)
++
++ def test_close_cleans_plugins(self):
++ p1, p2 = Mock(), Mock()
++ self.uzbl._plugin_instances = (p1, p2)
++ self.uzbl.plugins = {}
++ self.uzbl.close()
++ p1.cleanup.assert_called_once_with()
++ p2.cleanup.assert_called_once_with()
++
++ def test_close_connection_closes_protocol(self):
++ self.uzbl.close_connection(Mock())
++ self.proto.close.assert_called_once_with()
++
++ def test_exit_triggers_close(self):
++ self.uzbl.parse_msg(' '.join(['EVENT', 'spam', 'INSTANCE_EXIT']))
++ self.em.remove_instance.assert_called_once_with(self.proto.socket)
++
++ def test_instance_start(self):
++ pid = 1234
++ self.em.plugind.per_instance_plugins = []
++ self.uzbl.parse_msg(
++ ' '.join(['EVENT', 'spam', 'INSTANCE_START', str(pid)])
++ )
++ self.assertEqual(self.uzbl.pid, pid)
++
++ def test_init_plugins(self):
++ u = self.uzbl
++ class FooPlugin(object):
++ def __init__(self, uzbl): pass
++ class BarPlugin(object):
++ def __init__(self, uzbl): pass
++ self.em.plugind.per_instance_plugins = [FooPlugin, BarPlugin]
++ u.init_plugins()
++ self.assertEqual(len(u.plugins), 2)
++ for t in (FooPlugin, BarPlugin):
++ self.assertIn(t, u.plugins)
++ self.assertTrue(isinstance(u.plugins[t], t))
+diff --git a/tests/event-manager/testdoc.py b/tests/event-manager/testdoc.py
+new file mode 100755
+index 0000000..0f3b8eb
+--- /dev/null
++++ b/tests/event-manager/testdoc.py
+@@ -0,0 +1,22 @@
++#!/usr/bin/env python
++# vi: set et ts=4:
++
++import sys
++if '' not in sys.path:
++ sys.path.insert(0, '')
++
++import unittest
++from doctest import DocTestSuite
++keycmd_tests = DocTestSuite('uzbl.plugins.keycmd')
++arguments_tests = DocTestSuite('uzbl.arguments')
++
++
++def load_tests(loader, standard, pattern):
++ tests = unittest.TestSuite()
++ tests.addTest(keycmd_tests)
++ tests.addTest(arguments_tests)
++ return tests
++
++if __name__ == '__main__':
++ runner = unittest.TextTestRunner()
++ runner.run()
+diff --git a/tests/event-manager/testdownload.py b/tests/event-manager/testdownload.py
+new file mode 100644
+index 0000000..49ed726
+--- /dev/null
++++ b/tests/event-manager/testdownload.py
+@@ -0,0 +1,29 @@
++# vi: set et ts=4:
++
++
++
++import unittest
++from emtest import EventManagerMock
++
++from uzbl.plugins.config import Config
++from uzbl.plugins.downloads import Downloads
++
++
++class DownloadsTest(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock((), (Downloads, Config))
++ self.uzbl = self.event_manager.add()
++
++ def test_start(self):
++ cases = (
++ ('foo', 'foo', 'foo (0%)'),
++ ('"b@r"', 'b@r', 'b@r (0%'),
++ )
++ d = Downloads[self.uzbl]
++ for input, key, section in cases:
++ d.download_started(input)
++ self.assertIn(key, d.active_downloads)
++ self.assertEqual(d.active_downloads[key], 0)
++ self.uzbl.send.assert_called_once()
++ self.assertIn(section, self.uzbl.send.call_args[0][0])
++ self.uzbl.reset_mock()
+diff --git a/tests/event-manager/testhistory.py b/tests/event-manager/testhistory.py
+new file mode 100644
+index 0000000..0817d9f
+--- /dev/null
++++ b/tests/event-manager/testhistory.py
+@@ -0,0 +1,154 @@
++#!/usr/bin/env python
++# vi: set et ts=4:
++
++
++
++import sys
++if '' not in sys.path:
++ sys.path.insert(0, '')
++
++import unittest
++from emtest import EventManagerMock
++
++from uzbl.plugins.history import History, SharedHistory
++from uzbl.plugins.keycmd import Keylet, KeyCmd
++from uzbl.plugins.on_set import OnSetPlugin
++from uzbl.plugins.config import Config
++
++
++class SharedHistoryTest(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock((SharedHistory,), ())
++ self.uzbl = self.event_manager.add()
++ self.other = self.event_manager.add()
++
++ def test_instance(self):
++ a = SharedHistory[self.uzbl]
++ b = SharedHistory[self.other]
++ self.assertIs(a, b)
++
++ def test_add_and_get(self):
++ s = SharedHistory[self.uzbl]
++ s.addline('foo', 'bar')
++ s.addline('foo', 'baz')
++ s.addline('foo', 'bap')
++ self.assertEqual(s.get_line_number('foo'), 3)
++ self.assertEqual(s.get_line_number('other'), 0)
++ self.assertEqual(s.getline('foo', 0), 'bar')
++ self.assertEqual(s.getline('foo', 1), 'baz')
++ self.assertEqual(s.getline('foo', 2), 'bap')
++ self.assertEqual(s.getline('foo', -1), 'bap')
++
++ def test_empty_line_number(self):
++ s = SharedHistory[self.uzbl]
++ s.addline('foo', 'bar')
++ self.assertEqual(s.get_line_number(''), 0)
++ self.assertEqual(s.get_line_number('other'), 0)
++
++ def test_get_missing_prompt(self):
++ s = SharedHistory[self.uzbl]
++ s.addline('foo', 'bar')
++ self.assertRaises(IndexError, s.getline, 'bar', 0)
++
++
++class HistoryTest(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock(
++ (SharedHistory,),
++ (OnSetPlugin, KeyCmd, Config, History)
++ )
++ self.uzbl = self.event_manager.add()
++ self.other = self.event_manager.add()
++ s = SharedHistory[self.uzbl]
++ data = (
++ ('', 'woop'),
++ ('', 'doop'),
++ ('', 'bar'),
++ ('', 'foo'),
++ ('git', 'spam'),
++ ('git', 'egg'),
++ ('foo', 'foo')
++ )
++ for prompt, input in data:
++ s.addline(prompt, input)
++
++ def test_step(self):
++ h = History[self.uzbl]
++ self.assertEqual('', next(h))
++ self.assertEqual('', next(h))
++ self.assertEqual('foo', h.prev())
++ self.assertEqual('bar', h.prev())
++ self.assertEqual('foo', next(h))
++ self.assertEqual('bar', h.prev())
++ self.assertEqual('doop', h.prev())
++ self.assertEqual('woop', h.prev())
++ self.assertTrue(len(h.prev()) > 0)
++ self.assertTrue(len(h.prev()) > 0)
++ self.assertEqual('woop', next(h))
++
++ def test_step_prompt(self):
++ h = History[self.uzbl]
++ h.change_prompt('git')
++ self.assertEqual('', next(h))
++ self.assertEqual('', next(h))
++ self.assertEqual('egg', h.prev())
++ self.assertEqual('spam', h.prev())
++ self.assertTrue(len(h.prev()) > 0)
++ self.assertTrue(len(h.prev()) > 0)
++ self.assertEqual('spam', next(h))
++
++ def test_change_prompt(self):
++ h = History[self.uzbl]
++ self.assertEqual('foo', h.prev())
++ self.assertEqual('bar', h.prev())
++ h.change_prompt('git')
++ self.assertEqual('egg', h.prev())
++ self.assertEqual('spam', h.prev())
++
++ def test_exec(self):
++ modstate = set()
++ keylet = Keylet()
++ keylet.set_keycmd('foo')
++ History[self.uzbl].keycmd_exec(modstate, keylet)
++ s = SharedHistory[self.uzbl]
++ self.assertEqual(s.getline('', -1), 'foo')
++
++ def test_exec_from_history(self):
++ h = History[self.uzbl]
++ self.assertEqual('foo', h.prev())
++ self.assertEqual('bar', h.prev())
++ self.assertEqual('doop', h.prev())
++ modstate = set()
++ keylet = Keylet()
++ keylet.set_keycmd('doop')
++ h.keycmd_exec(modstate, keylet)
++ self.assertEqual('doop', h.prev())
++ self.assertEqual('foo', h.prev())
++ self.assertEqual('bar', h.prev())
++ # do we really want this one here ?
++ self.assertEqual('doop', h.prev())
++ self.assertEqual('woop', h.prev())
++
++ def test_search(self):
++ h = History[self.uzbl]
++ h.search('oop')
++ self.assertEqual('doop', h.prev())
++ self.assertEqual('woop', h.prev())
++ self.assertTrue(len(h.prev()) > 0)
++ self.assertEqual('woop', next(h))
++ self.assertEqual('doop', next(h))
++ # this reset the search
++ self.assertEqual('', next(h))
++ self.assertEqual('foo', h.prev())
++
++ def test_temp(self):
++ kl = KeyCmd[self.uzbl].keylet
++ kl.set_keycmd('uzbl')
++ h = History[self.uzbl]
++ h.change_prompt('foo')
++ # Why is the preserve current logic in this method?
++ h.history_prev(None)
++ self.assertTrue(len(h.prev()) > 0)
++ self.assertEqual('foo', next(h))
++ self.assertEqual('uzbl', next(h))
++ self.assertEqual('', next(h)) # this clears the keycmd
+diff --git a/tests/event-manager/testkeycmd.py b/tests/event-manager/testkeycmd.py
+new file mode 100644
+index 0000000..bc82c6d
+--- /dev/null
++++ b/tests/event-manager/testkeycmd.py
+@@ -0,0 +1,45 @@
++#!/usr/bin/env python
++
++import re
++import mock
++import unittest
++from emtest import EventManagerMock
++from uzbl.plugins.keycmd import KeyCmd
++from uzbl.plugins.config import Config
++
++
++def getkeycmd(s):
++ return re.match(r'@\[([^\]]*)\]@', s).group(1)
++
++class KeyCmdTest(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock(
++ (), (KeyCmd,),
++ (), ((Config, dict),)
++ )
++ self.uzbl = self.event_manager.add()
++
++ def test_press_key(self):
++ c, k = Config[self.uzbl], KeyCmd[self.uzbl]
++ k.key_press(('', 'a'))
++ self.assertEqual(c.get('modcmd', ''), '')
++ keycmd = getkeycmd(c['keycmd'])
++ self.assertEqual(keycmd, 'a')
++
++ def test_press_keys(self):
++ c, k = Config[self.uzbl], KeyCmd[self.uzbl]
++ string = 'uzbl'
++ for char in string:
++ k.key_press(('', char))
++ self.assertEqual(c.get('modcmd', ''), '')
++ keycmd = getkeycmd(c['keycmd'])
++ self.assertEqual(keycmd, string)
++
++ def test_press_unicode_keys(self):
++ c, k = Config[self.uzbl], KeyCmd[self.uzbl]
++ string = '\u5927\u962a\u5e02'
++ for char in string:
++ k.key_press(('', char))
++ self.assertEqual(c.get('modcmd', ''), '')
++ keycmd = getkeycmd(c['keycmd'])
++ self.assertEqual(keycmd, string)
+diff --git a/tests/event-manager/testmode.py b/tests/event-manager/testmode.py
+new file mode 100644
+index 0000000..d198c32
+--- /dev/null
++++ b/tests/event-manager/testmode.py
+@@ -0,0 +1,91 @@
++#!/usr/bin/env python
++# vi: set et ts=4:
++
++
++
++import unittest
++from emtest import EventManagerMock
++from uzbl.plugins.config import Config
++from uzbl.plugins.mode import ModePlugin
++from uzbl.plugins.on_set import OnSetPlugin
++
++class ModeParseTest(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock(
++ (), (OnSetPlugin, ModePlugin),
++ (), ((Config, dict),)
++ )
++ self.uzbl = self.event_manager.add()
++
++ def test_parse_config(self):
++ uzbl = self.uzbl
++ m = ModePlugin[uzbl]
++
++ mode, key, value = 'foo', 'x', 'y'
++ m.parse_mode_config((mode, key, '=', value))
++ self.assertIn(mode, m.mode_config)
++ self.assertIn(key, m.mode_config[mode])
++ self.assertEqual(m.mode_config[mode][key], value)
++
++
++class ModeTest(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock(
++ (), (OnSetPlugin, ModePlugin),
++ (), ((Config, dict),)
++ )
++ self.uzbl = self.event_manager.add()
++
++ mode = ModePlugin[self.uzbl]
++ config = Config[self.uzbl]
++
++ mode.parse_mode_config(('mode0', 'foo', '=', 'default'))
++
++ mode.parse_mode_config(('mode1', 'foo', '=', 'xxx'))
++ mode.parse_mode_config('mode1 bar = "spam spam"')
++ mode.parse_mode_config('mode1 baz = foo="baz"')
++
++ mode.parse_mode_config(('mode2', 'foo', '=', 'XXX'))
++ mode.parse_mode_config(('mode2', 'spam', '=', 'spam'))
++
++ config['default_mode'] = 'mode0'
++ mode.default_mode_updated(None, 'mode0')
++
++ def test_mode_sets_vars(self):
++ mode, config = ModePlugin[self.uzbl], Config[self.uzbl]
++ mode.mode_updated(None, 'mode1')
++
++ self.assertIn('foo', config)
++ self.assertIn('bar', config)
++ self.assertIn('baz', config)
++ self.assertEqual(config['foo'], 'xxx')
++ self.assertEqual(config['bar'], 'spam spam')
++ self.assertEqual(config['baz'], 'foo="baz"')
++
++ def test_mode_overwrite_vars(self):
++ mode, config = ModePlugin[self.uzbl], Config[self.uzbl]
++ config['mode'] = 'mode1'
++ mode.mode_updated(None, 'mode1')
++ config['mode'] = 'mode2'
++ mode.mode_updated(None, 'mode2')
++
++ self.assertIn('foo', config)
++ self.assertIn('bar', config)
++ self.assertIn('baz', config)
++ self.assertIn('spam', config)
++ self.assertEqual(config['foo'], 'XXX')
++ self.assertEqual(config['bar'], 'spam spam')
++ self.assertEqual(config['baz'], 'foo="baz"')
++ self.assertEqual(config['spam'], 'spam')
++
++ def test_default_mode(self):
++ ''' Setting to mode to nothing should enter the default mode'''
++ mode, config = ModePlugin[self.uzbl], Config[self.uzbl]
++
++ config['foo'] = 'nthth'
++ config['mode'] = ''
++ mode.mode_updated(None, '')
++ self.assertEqual(config['mode'], 'mode0')
++ mode.mode_updated(None, config['mode'])
++ self.assertEqual(config['mode'], 'mode0')
++ self.assertEqual(config['foo'], 'default')
+diff --git a/tests/event-manager/testonevent.py b/tests/event-manager/testonevent.py
+new file mode 100644
+index 0000000..7d80dbd
+--- /dev/null
++++ b/tests/event-manager/testonevent.py
+@@ -0,0 +1,59 @@
++#!/usr/bin/env python
++# vi: set et ts=4:
++
++
++
++import unittest
++from emtest import EventManagerMock
++from uzbl.plugins.config import Config
++from uzbl.plugins.mode import ModePlugin
++from uzbl.plugins.on_event import OnEventPlugin
++
++
++class OnEventTest(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock(
++ (), (OnEventPlugin,),
++ )
++ self.uzbl = self.event_manager.add()
++
++ def test_command(self):
++ oe = OnEventPlugin[self.uzbl]
++ event, command = 'FOO', 'test test'
++
++ oe.on_event(event, [], command)
++ oe.event_handler('', on_event=event)
++ self.uzbl.send.assert_called_once_with(command)
++
++ def test_matching_pattern(self):
++ oe = OnEventPlugin[self.uzbl]
++ event, pattern, command = 'FOO', ['BAR'], 'test test'
++
++ oe.on_event(event, pattern, command)
++ oe.event_handler('BAR else', on_event=event)
++ self.uzbl.send.assert_called_once_with(command)
++
++ def test_non_matching_pattern(self):
++ oe = OnEventPlugin[self.uzbl]
++ event, pattern, command = 'FOO', ['BAR'], 'test test'
++
++ oe.on_event(event, pattern, command)
++ oe.event_handler('FOO else', on_event=event)
++ self.assertFalse(self.uzbl.send.called)
++
++ def test_parse(self):
++ oe = OnEventPlugin[self.uzbl]
++ event, command = 'FOO', 'test test'
++
++ oe.parse_on_event((event, command))
++ self.assertIn(event, oe.events)
++
++ def test_parse_pattern(self):
++ oe = OnEventPlugin[self.uzbl]
++ event, pattern, command = 'FOO', 'BAR', 'test test'
++
++ oe.parse_on_event((event, '[', pattern, ']', command))
++ self.assertIn(event, oe.events)
++ commands = oe.events[event]
++ self.assertIn(command, commands)
++ self.assertEqual(commands[command], [pattern])
+diff --git a/tests/event-manager/testprogressbar.py b/tests/event-manager/testprogressbar.py
+new file mode 100644
+index 0000000..93ebaa8
+--- /dev/null
++++ b/tests/event-manager/testprogressbar.py
+@@ -0,0 +1,94 @@
++#!/usr/bin/env python
++# vi: set et ts=4:
++
++
++
++import sys
++if '' not in sys.path:
++ sys.path.insert(0, '')
++
++import unittest
++from emtest import EventManagerMock
++from uzbl.plugins.config import Config
++from uzbl.plugins.progress_bar import ProgressBar
++
++
++class ProgressBarTest(unittest.TestCase):
++ def setUp(self):
++ self.event_manager = EventManagerMock(
++ (), (ProgressBar,),
++ (), ((Config, dict),)
++ )
++ self.uzbl = self.event_manager.add()
++
++ def test_percent_done(self):
++ uzbl = self.uzbl
++ p, c = ProgressBar[uzbl], Config[uzbl]
++ c['progress.format'] = '%c'
++
++ p.update_progress()
++ inout = (
++ (9, '9%'),
++ (99, '99%'),
++ (100, '100%'),
++ #(101, '100%') # TODO
++ )
++
++ for i, o in inout:
++ p.update_progress(i)
++ self.assertEqual(c['progress.output'], o)
++
++ def test_done_char(self):
++ uzbl = self.uzbl
++ p, c = ProgressBar[uzbl], Config[uzbl]
++ c['progress.format'] = '%d'
++
++ p.update_progress()
++ inout = (
++ (9, '='),
++ (50, '===='),
++ (99, '========'),
++ (100, '========'),
++ (101, '========')
++ )
++
++ for i, o in inout:
++ p.update_progress(i)
++ self.assertEqual(c['progress.output'], o)
++
++ def test_pending_char(self):
++ uzbl = self.uzbl
++ p, c = ProgressBar[uzbl], Config[uzbl]
++ c['progress.format'] = '%p'
++ c['progress.pending'] = '-'
++
++ p.update_progress()
++ inout = (
++ (9, '-------'),
++ (50, '----'),
++ (99, ''),
++ (100, ''),
++ (101, '')
++ )
++
++ for i, o in inout:
++ p.update_progress(i)
++ self.assertEqual(c['progress.output'], o)
++
++ def test_percent_pending(self):
++ uzbl = self.uzbl
++ p, c = ProgressBar[uzbl], Config[uzbl]
++ c['progress.format'] = '%t'
++
++ p.update_progress()
++ inout = (
++ (9, '91%'),
++ (50, '50%'),
++ (99, '1%'),
++ (100, '0%'),
++ #(101, '0%') # TODO
++ )
++
++ for i, o in inout:
++ p.update_progress(i)
++ self.assertEqual(c['progress.output'], o)
+diff --git a/uzbl/__init__.py b/uzbl/__init__.py
+new file mode 100644
+index 0000000..58f0d85
+--- /dev/null
++++ b/uzbl/__init__.py
+@@ -0,0 +1,6 @@
++'''
++Event manager for uzbl
++
++A event manager for uzbl that supports plugins and multiple simultaneus
++connections from uzbl-core(s)
++'''
+diff --git a/uzbl/arguments.py b/uzbl/arguments.py
+new file mode 100644
+index 0000000..7f71b74
+--- /dev/null
++++ b/uzbl/arguments.py
+@@ -0,0 +1,103 @@
++'''
++Arguments parser
++
++provides argument parsing for event handlers
++'''
++
++import re
++import ast
++
++
++class Arguments(tuple):
++ '''
++ Given a argument line gives access to the split parts
++ honoring common quotation and escaping rules
++
++ >>> Arguments(r"simple 'quoted string'")
++ ('simple', 'quoted string')
++ '''
++
++ _splitquoted = re.compile("(\s+|\"(?:\\\\.|[^\"])*?\"|'(?:\\\\.|[^'])*?')")
++
++ def __new__(cls, s):
++ '''
++ >>> Arguments(r"one two three")
++ ('one', 'two', 'three')
++ >>> Arguments(r"spam 'escaping \\'works\\''")
++ ('spam', "escaping 'works'")
++ >>> # For testing purposes we can pass a preparsed tuple
++ >>> Arguments(('foo', 'bar', 'baz az'))
++ ('foo', 'bar', 'baz az')
++ '''
++ if isinstance(s, tuple):
++ self = tuple.__new__(cls, s)
++ self._raw, self._ref = s, list(range(len(s)))
++ return self
++ raw = cls._splitquoted.split(s)
++ ref = []
++ self = tuple.__new__(cls, cls.parse(raw, ref))
++ self._raw, self._ref = raw, ref
++ return self
++
++ @classmethod
++ def parse(cls, raw, ref):
++ '''
++ Generator used to initialise the arguments tuple
++
++ Indexes to where in source list the arguments start will be put in 'ref'
++ '''
++ c = None
++ for i, part in enumerate(raw):
++ if re.match('\s+', part):
++ # Whitespace ends the current argument, leading ws is ignored
++ if c is not None:
++ yield c
++ c = None
++ else:
++ f = unquote(part)
++ if c is None:
++ # Mark the start of the argument in the raw input
++ if part != '':
++ ref.append(i)
++ c = f
++ else:
++ c += f
++ if c is not None:
++ yield c
++
++ def raw(self, frm=0, to=None):
++ '''
++ Returs the portion of the raw input that yielded arguments
++ from 'frm' to 'to'
++
++ >>> args = Arguments(r"'spam, spam' egg sausage and 'spam'")
++ >>> args
++ ('spam, spam', 'egg', 'sausage', 'and', 'spam')
++ >>> args.raw(1)
++ "egg sausage and 'spam'"
++ '''
++ if len(self._ref) < 1:
++ return ''
++ rfrm = self._ref[frm]
++ if to is None or len(self._ref) <= to + 1:
++ rto = len(self._raw)
++ else:
++ rto = self._ref[to + 1] - 1
++ return ''.join(self._raw[rfrm:rto])
++
++splitquoted = Arguments # or define a function?
++
++
++def is_quoted(s):
++ return s and s[0] == s[-1] and s[0] in "'\""
++
++
++def unquote(s):
++ '''
++ Returns the input string without quotations and with
++ escape sequences interpreted
++ '''
++
++ if is_quoted(s):
++ return ast.literal_eval(s)
++ return ast.literal_eval('"' + s + '"')
+diff --git a/uzbl/core.py b/uzbl/core.py
+new file mode 100644
+index 0000000..d0f9010
+--- /dev/null
++++ b/uzbl/core.py
+@@ -0,0 +1,153 @@
++import time
++import logging
++from collections import defaultdict
++
++
++class Uzbl(object):
++
++ def __init__(self, parent, proto, options):
++ proto.target = self
++ self.opts = options
++ self.parent = parent
++ self.proto = proto
++ self.time = time.time()
++ self.pid = None
++ self.name = None
++
++ # Flag if the instance has raised the INSTANCE_START event.
++ self.instance_start = False
++
++ # Use name "unknown" until name is discovered.
++ self.logger = logging.getLogger('uzbl-instance[]')
++
++ # Plugin instances
++ self._plugin_instances = []
++ self.plugins = {}
++
++ # Track plugin event handlers
++ self.handlers = defaultdict(list)
++
++ # Internal vars
++ self._depth = 0
++ self._buffer = ''
++
++ def __repr__(self):
++ return '<uzbl(%s)>' % ', '.join([
++ 'pid=%s' % (self.pid if self.pid else "Unknown"),
++ 'name=%s' % ('%r' % self.name if self.name else "Unknown"),
++ 'uptime=%f' % (time.time() - self.time),
++ '%d handlers' % sum([len(l) for l in list(self.handlers.values())])])
++
++ def init_plugins(self):
++ '''Creates instances of per-instance plugins'''
++
++ for plugin in self.parent.plugind.per_instance_plugins:
++ pinst = plugin(self)
++ self._plugin_instances.append(pinst)
++ self.plugins[plugin] = pinst
++
++ def send(self, msg):
++ '''Send a command to the uzbl instance via the child socket
++ instance.'''
++
++ msg = msg.strip()
++
++ if self.opts.print_events:
++ print(('%s<-- %s' % (' ' * self._depth, msg)))
++
++ self.proto.push((msg+'\n').encode('utf-8'))
++
++ def parse_msg(self, line):
++ '''Parse an incoming message from a uzbl instance. Event strings
++ will be parsed into `self.event(event, args)`.'''
++
++ # Split by spaces (and fill missing with nulls)
++ elems = (line.split(' ', 3) + [''] * 3)[:4]
++
++ # Ignore non-event messages.
++ if elems[0] != 'EVENT':
++ self.logger.info('non-event message: %r', line)
++ if self.opts.print_events:
++ print(('--- %s' % line))
++ return
++
++ # Check event string elements
++ (name, event, args) = elems[1:]
++ assert name and event, 'event string missing elements'
++ if not self.name:
++ self.name = name
++ self.logger = logging.getLogger('uzbl-instance%s' % name)
++ self.logger.info('found instance name %r', name)
++
++ assert self.name == name, 'instance name mismatch'
++
++ # Handle the event with the event handlers through the event method
++ self.event(event, args)
++
++ def event(self, event, *args, **kargs):
++ '''Raise an event.'''
++
++ event = event.upper()
++
++ if not self.opts.daemon_mode and self.opts.print_events:
++ elems = [event]
++ if args:
++ elems.append(str(args))
++ if kargs:
++ elems.append(str(kargs))
++ print(('%s--> %s' % (' ' * self._depth, ' '.join(elems))))
++
++ if event == "INSTANCE_START" and args:
++ assert not self.instance_start, 'instance already started'
++
++ self.pid = int(args[0])
++ self.logger.info('found instance pid %r', self.pid)
++
++ self.init_plugins()
++
++ elif event == "INSTANCE_EXIT":
++ self.logger.info('uzbl instance exit')
++ self.close()
++
++ if event not in self.handlers:
++ return
++
++ for handler in self.handlers[event]:
++ self._depth += 1
++ try:
++ handler(*args, **kargs)
++
++ except Exception:
++ self.logger.error('error in handler', exc_info=True)
++
++ self._depth -= 1
++
++ def close_connection(self, child_socket):
++ '''Close child socket and delete the uzbl instance created for that
++ child socket connection.'''
++ self.proto.close()
++
++ def close(self):
++ '''Close the client socket and call the plugin cleanup hooks.'''
++
++ self.logger.debug('called close method')
++
++ # Remove self from parent uzbls dict.
++ self.logger.debug('removing self from uzbls list')
++ self.parent.remove_instance(self.proto.socket)
++
++ for plugin in self._plugin_instances:
++ plugin.cleanup()
++ del self.plugins # to avoid cyclic links
++ del self._plugin_instances
++
++ self.logger.info('removed %r', self)
++
++ def connect(self, name, handler):
++ """Attach event handler
++
++ No extra arguments added. Use bound methods and partials to have
++ extra arguments.
++ """
++ self.handlers[name].append(handler)
++
+diff --git a/uzbl/event_manager.py b/uzbl/event_manager.py
+new file mode 100755
+index 0000000..fcf9a47
+--- /dev/null
++++ b/uzbl/event_manager.py
+@@ -0,0 +1,540 @@
++#!/usr/bin/env python3
++
++
++# Event Manager for Uzbl
++# Copyright (c) 2009-2010, Mason Larobina <mason.larobina@gmail.com>
++# Copyright (c) 2009, Dieter Plaetinck <dieter@plaetinck.be>
++#
++# This program is free software: you can redistribute it and/or modify
++# it under the terms of the GNU General Public License as published by
++# the Free Software Foundation, either version 3 of the License, or
++# (at your option) any later version.
++#
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++# GNU General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++'''
++
++E V E N T _ M A N A G E R . P Y
++===============================
++
++Event manager for uzbl written in python.
++
++'''
++
++import atexit
++import imp
++import logging
++import os
++import sys
++import time
++import weakref
++import re
++import errno
++import asyncore
++from collections import defaultdict
++from functools import partial
++from glob import glob
++from itertools import count
++from optparse import OptionParser
++from select import select
++from signal import signal, SIGTERM, SIGINT, SIGKILL
++from traceback import format_exc
++
++from uzbl.net import Listener, Protocol
++from uzbl.core import Uzbl
++
++def xdghome(key, default):
++ '''Attempts to use the environ XDG_*_HOME paths if they exist otherwise
++ use $HOME and the default path.'''
++
++ xdgkey = "XDG_%s_HOME" % key
++ if xdgkey in list(os.environ.keys()) and os.environ[xdgkey]:
++ return os.environ[xdgkey]
++
++ return os.path.join(os.environ['HOME'], default)
++
++# Setup xdg paths.
++DATA_DIR = os.path.join(xdghome('DATA', '.local/share/'), 'uzbl/')
++CACHE_DIR = os.path.join(xdghome('CACHE', '.cache/'), 'uzbl/')
++
++# Define some globals.
++SCRIPTNAME = os.path.basename(sys.argv[0])
++
++logger = logging.getLogger(SCRIPTNAME)
++
++
++def get_exc():
++ '''Format `format_exc` for logging.'''
++ return "\n%s" % format_exc().rstrip()
++
++
++def expandpath(path):
++ '''Expand and realpath paths.'''
++ return os.path.realpath(os.path.expandvars(path))
++
++
++
++def daemonize():
++ '''Daemonize the process using the Stevens' double-fork magic.'''
++
++ logger.info('entering daemon mode')
++
++ try:
++ if os.fork():
++ os._exit(0)
++
++ except OSError:
++ logger.critical('failed to daemonize', exc_info=True)
++ sys.exit(1)
++
++ os.chdir('/')
++ os.setsid()
++ os.umask(0)
++
++ try:
++ if os.fork():
++ os._exit(0)
++
++ except OSError:
++ logger.critical('failed to daemonize', exc_info=True)
++ sys.exit(1)
++
++ if sys.stdout.isatty():
++ sys.stdout.flush()
++ sys.stderr.flush()
++
++ devnull = '/dev/null'
++ stdin = open(devnull, 'r')
++ stdout = open(devnull, 'a+')
++ stderr = open(devnull, 'a+')
++
++ os.dup2(stdin.fileno(), sys.stdin.fileno())
++ os.dup2(stdout.fileno(), sys.stdout.fileno())
++ os.dup2(stderr.fileno(), sys.stderr.fileno())
++
++ logger.info('entered daemon mode')
++
++
++def make_dirs(path):
++ '''Make all basedirs recursively as required.'''
++
++ try:
++ dirname = os.path.dirname(path)
++ if not os.path.isdir(dirname):
++ logger.debug('creating directories %r', dirname)
++ os.makedirs(dirname)
++
++ except OSError:
++ logger.error('failed to create directories', exc_info=True)
++
++
++class PluginDirectory(object):
++ def __init__(self):
++ self.global_plugins = []
++ self.per_instance_plugins = []
++
++ def load(self):
++ ''' Import plugin files '''
++
++ import uzbl.plugins
++ import pkgutil
++
++ path = uzbl.plugins.__path__
++ for impr, name, ispkg in pkgutil.iter_modules(path, 'uzbl.plugins.'):
++ __import__(name, globals(), locals())
++
++ from uzbl.ext import global_registry, per_instance_registry
++ self.global_plugins.extend(global_registry)
++ self.per_instance_plugins.extend(per_instance_registry)
++
++
++class UzblEventDaemon(object):
++ def __init__(self, listener, plugind):
++ listener.target = self
++ self.opts = opts
++ self.listener = listener
++ self.plugind = plugind
++ self._quit = False
++
++ # Hold uzbl instances
++ # {child socket: Uzbl instance, ..}
++ self.uzbls = {}
++
++ self.plugins = {}
++
++ # Register that the event daemon server has started by creating the
++ # pid file.
++ make_pid_file(opts.pid_file)
++
++ # Register a function to clean up the socket and pid file on exit.
++ atexit.register(self.quit)
++
++ # Add signal handlers.
++ for sigint in [SIGTERM, SIGINT]:
++ signal(sigint, self.quit)
++
++ # Scan plugin directory for plugins
++ self.plugind.load()
++
++ # Initialise global plugins with instances in self.plugins
++ self.init_plugins()
++
++ def init_plugins(self):
++ '''Initialise event manager plugins.'''
++ self._plugin_instances = []
++ self.plugins = {}
++
++ for plugin in self.plugind.global_plugins:
++ pinst = plugin(self)
++ self._plugin_instances.append(pinst)
++ self.plugins[plugin] = pinst
++
++ def run(self):
++ '''Main event daemon loop.'''
++
++ logger.debug('entering main loop')
++
++ if opts.daemon_mode:
++ # Daemonize the process
++ daemonize()
++
++ # Update the pid file
++ make_pid_file(opts.pid_file)
++
++ asyncore.loop()
++
++ # Clean up and exit
++ self.quit()
++
++ logger.debug('exiting main loop')
++
++ def add_instance(self, sock):
++ proto = Protocol(sock)
++ uzbl = Uzbl(self, proto, opts)
++ self.uzbls[sock] = uzbl
++
++ def remove_instance(self, sock):
++ if sock in self.uzbls:
++ del self.uzbls[sock]
++ if not self.uzbls and opts.auto_close:
++ self.quit()
++
++ def close_server_socket(self):
++ '''Close and delete the server socket.'''
++
++ try:
++ self.listener.close()
++
++ except:
++ logger.error('failed to close server socket', exc_info=True)
++
++ def quit(self, sigint=None, *args):
++ '''Close all instance socket objects, server socket and delete the
++ pid file.'''
++
++ if sigint == SIGTERM:
++ logger.critical('caught SIGTERM, exiting')
++
++ elif sigint == SIGINT:
++ logger.critical('caught SIGINT, exiting')
++
++ elif not self._quit:
++ logger.debug('shutting down event manager')
++
++ self.close_server_socket()
++
++ for uzbl in list(self.uzbls.values()):
++ uzbl.close()
++
++ if not self._quit:
++ for plugin in self._plugin_instances:
++ plugin.cleanup()
++ del self.plugins # to avoid cyclic links
++ del self._plugin_instances
++
++ del_pid_file(opts.pid_file)
++
++ if not self._quit:
++ logger.info('event manager shut down')
++ self._quit = True
++ raise SystemExit()
++
++
++def make_pid_file(pid_file):
++ '''Creates a pid file at `pid_file`, fails silently.'''
++
++ try:
++ logger.debug('creating pid file %r', pid_file)
++ make_dirs(pid_file)
++ pid = os.getpid()
++ fileobj = open(pid_file, 'w')
++ fileobj.write('%d' % pid)
++ fileobj.close()
++ logger.info('created pid file %r with pid %d', pid_file, pid)
++
++ except:
++ logger.error('failed to create pid file', exc_info=True)
++
++
++def del_pid_file(pid_file):
++ '''Deletes a pid file at `pid_file`, fails silently.'''
++
++ if os.path.isfile(pid_file):
++ try:
++ logger.debug('deleting pid file %r', pid_file)
++ os.remove(pid_file)
++ logger.info('deleted pid file %r', pid_file)
++
++ except:
++ logger.error('failed to delete pid file', exc_info=True)
++
++
++def get_pid(pid_file):
++ '''Reads a pid from pid file `pid_file`, fails None.'''
++
++ try:
++ logger.debug('reading pid file %r', pid_file)
++ fileobj = open(pid_file, 'r')
++ pid = int(fileobj.read())
++ fileobj.close()
++ logger.info('read pid %d from pid file %r', pid, pid_file)
++ return pid
++
++ except (IOError, ValueError):
++ logger.error('failed to read pid', exc_info=True)
++ return None
++
++
++def pid_running(pid):
++ '''Checks if a process with a pid `pid` is running.'''
++
++ try:
++ os.kill(pid, 0)
++ except OSError:
++ return False
++ else:
++ return True
++
++
++def term_process(pid):
++ '''Asks nicely then forces process with pid `pid` to exit.'''
++
++ try:
++ logger.info('sending SIGTERM to process with pid %r', pid)
++ os.kill(pid, SIGTERM)
++
++ except OSError:
++ logger.error(get_exc())
++
++ logger.debug('waiting for process with pid %r to exit', pid)
++ start = time.time()
++ while True:
++ if not pid_running(pid):
++ logger.debug('process with pid %d exit', pid)
++ return True
++
++ if (time.time() - start) > 5:
++ logger.warning('process with pid %d failed to exit', pid)
++ logger.info('sending SIGKILL to process with pid %d', pid)
++ try:
++ os.kill(pid, SIGKILL)
++ except:
++ logger.critical('failed to kill %d', pid, exc_info=True)
++ raise
++
++ if (time.time() - start) > 10:
++ logger.critical('unable to kill process with pid %d', pid)
++ raise OSError
++
++ time.sleep(0.25)
++
++
++def stop_action():
++ '''Stop the event manager daemon.'''
++
++ pid_file = opts.pid_file
++ if not os.path.isfile(pid_file):
++ logger.error('could not find running event manager with pid file %r',
++ pid_file)
++ return
++
++ pid = get_pid(pid_file)
++ if not pid_running(pid):
++ logger.debug('no process with pid %r', pid)
++ del_pid_file(pid_file)
++ return
++
++ logger.debug('terminating process with pid %r', pid)
++ term_process(pid)
++ del_pid_file(pid_file)
++ logger.info('stopped event manager process with pid %d', pid)
++
++
++def start_action():
++ '''Start the event manager daemon.'''
++
++ pid_file = opts.pid_file
++ if os.path.isfile(pid_file):
++ pid = get_pid(pid_file)
++ if pid_running(pid):
++ logger.error('event manager already started with pid %d', pid)
++ return
++
++ logger.info('no process with pid %d', pid)
++ del_pid_file(pid_file)
++
++ listener = Listener(opts.server_socket)
++ listener.start()
++ plugind = PluginDirectory()
++ daemon = UzblEventDaemon(listener, plugind)
++ daemon.run()
++
++
++def restart_action():
++ '''Restart the event manager daemon.'''
++
++ stop_action()
++ start_action()
++
++
++def list_action():
++ '''List all the plugins that would be loaded in the current search
++ dirs.'''
++
++ from types import ModuleType
++ import uzbl.plugins
++ import pkgutil
++ for line in pkgutil.iter_modules(uzbl.plugins.__path__, 'uzbl.plugins.'):
++ imp, name, ispkg = line
++ print(name)
++
++
++def make_parser():
++ parser = OptionParser('usage: %prog [options] {start|stop|restart|list}')
++ add = parser.add_option
++
++ add('-v', '--verbose',
++ dest='verbose', default=2, action='count',
++ help='increase verbosity')
++
++ socket_location = os.path.join(CACHE_DIR, 'event_daemon')
++
++ add('-s', '--server-socket',
++ dest='server_socket', metavar="SOCKET", default=socket_location,
++ help='server AF_UNIX socket location')
++
++ add('-p', '--pid-file',
++ metavar="FILE", dest='pid_file',
++ help='pid file location, defaults to server socket + .pid')
++
++ add('-n', '--no-daemon',
++ dest='daemon_mode', action='store_false', default=True,
++ help='do not daemonize the process')
++
++ add('-a', '--auto-close',
++ dest='auto_close', action='store_true', default=False,
++ help='auto close after all instances disconnect')
++
++ add('-o', '--log-file',
++ dest='log_file', metavar='FILE',
++ help='write logging output to a file, defaults to server socket +'
++ ' .log')
++
++ add('-q', '--quiet-events',
++ dest='print_events', action="store_false", default=True,
++ help="silence the printing of events to stdout")
++
++ return parser
++
++
++def init_logger():
++ log_level = logging.CRITICAL - opts.verbose * 10
++ logger = logging.getLogger()
++ logger.setLevel(max(log_level, 10))
++
++ # Console
++ handler = logging.StreamHandler()
++ handler.setLevel(max(log_level + 10, 10))
++ handler.setFormatter(logging.Formatter(
++ '%(name)s: %(levelname)s: %(message)s'))
++ logger.addHandler(handler)
++
++ # Logfile
++ handler = logging.FileHandler(opts.log_file, 'w', 'utf-8', 1)
++ handler.setLevel(max(log_level, 10))
++ handler.setFormatter(logging.Formatter(
++ '[%(created)f] %(name)s: %(levelname)s: %(message)s'))
++ logger.addHandler(handler)
++
++
++def main():
++ global opts
++
++ parser = make_parser()
++
++ (opts, args) = parser.parse_args()
++
++ opts.server_socket = expandpath(opts.server_socket)
++
++ # Set default pid file location
++ if not opts.pid_file:
++ opts.pid_file = "%s.pid" % opts.server_socket
++
++ else:
++ opts.pid_file = expandpath(opts.pid_file)
++
++ # Set default log file location
++ if not opts.log_file:
++ opts.log_file = "%s.log" % opts.server_socket
++
++ else:
++ opts.log_file = expandpath(opts.log_file)
++
++ # Logging setup
++ init_logger()
++ logger.info('logging to %r', opts.log_file)
++
++ if opts.auto_close:
++ logger.debug('will auto close')
++ else:
++ logger.debug('will not auto close')
++
++ if opts.daemon_mode:
++ logger.debug('will daemonize')
++ else:
++ logger.debug('will not daemonize')
++
++ # init like {start|stop|..} daemon actions
++ daemon_actions = {'start': start_action, 'stop': stop_action,
++ 'restart': restart_action, 'list': list_action}
++
++ if len(args) == 1:
++ action = args[0]
++ if action not in daemon_actions:
++ parser.error('invalid action: %r' % action)
++
++ elif not args:
++ action = 'start'
++ logger.warning('no daemon action given, assuming %r', action)
++
++ else:
++ parser.error('invalid action argument: %r' % args)
++
++ logger.info('daemon action %r', action)
++ # Do action
++ daemon_actions[action]()
++
++ logger.debug('process CPU time: %f', time.clock())
++
++
++if __name__ == "__main__":
++ main()
++
++
++# vi: set et ts=4:
+diff --git a/uzbl/ext.py b/uzbl/ext.py
+new file mode 100644
+index 0000000..b2795ed
+--- /dev/null
++++ b/uzbl/ext.py
+@@ -0,0 +1,92 @@
++from .event_manager import Uzbl
++import logging
++
++
++per_instance_registry = []
++global_registry = []
++
++
++class PluginMeta(type):
++ """Registers plugin in registry so that it instantiates when needed"""
++
++ def __init__(self, name, bases, dic):
++ super(PluginMeta, self).__init__(name, bases, dic)
++ # Sorry, a bit of black magick
++ if bases == (object,) or bases == (BasePlugin,):
++ # base classes for the plugins
++ return
++ if issubclass(self, PerInstancePlugin):
++ per_instance_registry.append(self)
++ elif issubclass(self, GlobalPlugin):
++ global_registry.append(self)
++
++ def __getitem__(self, owner):
++ """This method returns instance of plugin corresponding to owner
++
++ :param owner: can be uzbl or event manager
++
++ If you will try to get instance of :class:`GlobalPlugin` on uzbl
++ instance it will find instance on it's parent. If you will try to
++ find instance of a :class:`PerInstancePlugin` it will raise
++ :class:`ValueError`
++ """
++ return self._get_instance(owner)
++
++
++class BasePlugin(object, metaclass=PluginMeta):
++ """Base class for all uzbl plugins"""
++
++
++class PerInstancePlugin(BasePlugin):
++ """Base class for plugins which instantiate once per uzbl instance"""
++
++ def __init__(self, uzbl):
++ self.uzbl = uzbl
++ self.logger = uzbl.logger # we can also append plugin name to logger
++
++ def cleanup(self):
++ """Cleanup state after instance is gone
++
++ Default function avoids cyclic refrences, so don't forget to call
++ super() if overriding
++ """
++ del self.uzbl
++
++ @classmethod
++ def _get_instance(cls, owner):
++ """Returns instance of the plugin
++
++ This method should be private to not violate TOOWTDI
++ """
++ if not isinstance(owner, Uzbl):
++ raise ValueError("Can only get {0} instance for uzbl, not {1}"
++ .format(cls.__name__, type(owner).__name__))
++ # TODO(tailhook) probably subclasses can be returned as well
++ return owner.plugins[cls]
++
++
++class GlobalPlugin(BasePlugin):
++ """Base class for plugins which instantiate once per daemon"""
++
++ def __init__(self, event_manager):
++ self.event_manager = event_manager
++ self.logger = logging.getLogger(self.__module__)
++
++ @classmethod
++ def _get_instance(cls, owner):
++ """Returns instance of the plugin
++
++ This method should be private to not violate TOOWTDI
++ """
++ if isinstance(owner, Uzbl):
++ owner = owner.parent
++ # TODO(tailhook) probably subclasses can be returned as well
++ return owner.plugins[cls]
++
++ def cleanup(self):
++ """Cleanup state after instance is gone
++
++ Default function avoids cyclic refrences, so don't forget to call
++ super() if overriding
++ """
++ del self.event_manager
+diff --git a/uzbl/net.py b/uzbl/net.py
+new file mode 100644
+index 0000000..2c34e7b
+--- /dev/null
++++ b/uzbl/net.py
+@@ -0,0 +1,109 @@
++# Network communication classes
++# vi: set et ts=4:
++import asyncore
++import asynchat
++import socket
++import os
++import logging
++
++logger = logging.getLogger('uzbl.net')
++
++
++class NoTargetSet(Exception):
++ pass
++
++
++class TargetAlreadySet(Exception):
++ pass
++
++
++class WithTarget(object):
++ '''
++ Mixin that adds a property 'target' than can only be set once and
++ raises an exception if not set when accesed
++ '''
++
++ @property
++ def target(self):
++ try:
++ return self._target
++ except AttributeError as e:
++ raise NoTargetSet("No target for %r" % self, e)
++
++ @target.setter
++ def target(self, value):
++ if hasattr(self, '_target') and self._target is not None:
++ raise TargetAlreadySet(
++ "target of listener already set (%r)" % self._target
++ )
++ self._target = value
++
++
++class Listener(asyncore.dispatcher, WithTarget):
++ ''' Waits for new connections and accept()s them '''
++
++ def __init__(self, addr, target=None):
++ asyncore.dispatcher.__init__(self)
++ self.addr = addr
++ self.target = target
++
++ def start(self):
++ self.create_socket(socket.AF_UNIX, socket.SOCK_STREAM)
++ self.knock()
++ self.set_reuse_addr()
++ self.bind(self.addr)
++ self.listen(5)
++
++ def knock(self):
++ '''Unlink existing socket if it's stale'''
++
++ if os.path.exists(self.addr):
++ logger.info('socket already exists, checking if active')
++ s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
++ try:
++ s.connect(self.addr)
++ except socket.error as e:
++ logger.info('unlinking %r', self.addr)
++ os.unlink(self.addr)
++
++ def writable(self):
++ return False
++
++ def handle_accept(self):
++ try:
++ sock, addr = self.accept()
++ except socket.error:
++ return
++ else:
++ self.target.add_instance(sock)
++
++ def close(self):
++ super(Listener, self).close()
++ if os.path.exists(self.addr):
++ logger.info('unlinking %r', self.addr)
++ os.unlink(self.addr)
++
++ def handle_error(self):
++ raise
++
++
++class Protocol(asynchat.async_chat):
++ ''' A connection with a single client '''
++
++ def __init__(self, socket, target=None):
++ asynchat.async_chat.__init__(self, socket)
++ self.socket = socket
++ self.target = target
++ self.buffer = bytearray()
++ self.set_terminator(b'\n')
++
++ def collect_incoming_data(self, data):
++ self.buffer += data
++
++ def found_terminator(self):
++ val = self.buffer.decode('utf-8')
++ del self.buffer[:]
++ self.target.parse_msg(val)
++
++ def handle_error(self):
++ raise
+diff --git a/uzbl/plugins/__init__.py b/uzbl/plugins/__init__.py
+new file mode 100644
+index 0000000..84cf2ec
+--- /dev/null
++++ b/uzbl/plugins/__init__.py
+@@ -0,0 +1,14 @@
++'''
++Plugins collection
++
++plugins for use with uzbl-event-manager
++'''
++
++import os.path
++
++plugin_path = os.environ.get("UZBL_PLUGIN_PATH",
++ "~/.local/share/uzbl/plugins:/usr/share/uzbl/site-plugins",
++ ).split(":")
++if plugin_path:
++ __path__ = list(map(os.path.expanduser, plugin_path)) + __path__
++
+diff --git a/uzbl/plugins/bind.py b/uzbl/plugins/bind.py
+new file mode 100644
+index 0000000..f40da36
+--- /dev/null
++++ b/uzbl/plugins/bind.py
+@@ -0,0 +1,463 @@
++'''Plugin provides support for binds in uzbl.
++
++For example:
++ event BIND ZZ = exit -> bind('ZZ', 'exit')
++ event BIND o _ = uri %s -> bind('o _', 'uri %s')
++ event BIND fl* = sh 'echo %s' -> bind('fl*', "sh 'echo %s'")
++
++And it is also possible to execute a function on activation:
++ bind('DD', myhandler)
++'''
++
++import sys
++import re
++from functools import partial
++from itertools import count
++
++from uzbl.arguments import unquote, splitquoted
++from uzbl.ext import PerInstancePlugin
++from .cmd_expand import cmd_expand
++from .config import Config
++from .keycmd import KeyCmd
++import collections
++
++# Commonly used regular expressions.
++MOD_START = re.compile('^<([A-Z][A-Za-z0-9-_]*)>').match
++# Matches <x:y>, <'x':y>, <:'y'>, <x!y>, <'x'!y>, ...
++PROMPTS = '<(\"[^\"]*\"|\'[^\']*\'|[^:!>]*)(:|!)(\"[^\"]*\"|\'[^\']*\'|[^>]*)>'
++FIND_PROMPTS = re.compile(PROMPTS).split
++VALID_MODE = re.compile('^(-|)[A-Za-z0-9][A-Za-z0-9_]*$').match
++
++# For accessing a bind glob stack.
++ON_EXEC, HAS_ARGS, MOD_CMD, GLOB, MORE = list(range(5))
++
++
++# Custom errors.
++class ArgumentError(Exception): pass
++
++
++class Bindlet(object):
++ '''Per-instance bind status/state tracker.'''
++
++ def __init__(self, uzbl):
++ self.binds = {'global': {}}
++ self.uzbl = uzbl
++ self.uzbl_config = Config[uzbl]
++ self.depth = 0
++ self.args = []
++ self.last_mode = None
++ self.after_cmds = None
++ self.stack_binds = []
++
++ # A subset of the global mode binds containing non-stack and modkey
++ # activiated binds for use in the stack mode.
++ self.globals = []
++
++
++ def __getitem__(self, key):
++ return self.get_binds(key)
++
++
++ def reset(self):
++ '''Reset the tracker state and return to last mode.'''
++
++ self.depth = 0
++ self.args = []
++ self.after_cmds = None
++ self.stack_binds = []
++
++ if self.last_mode:
++ mode, self.last_mode = self.last_mode, None
++ self.uzbl_config['mode'] = mode
++
++ del self.uzbl_config['keycmd_prompt']
++
++
++ def stack(self, bind, args, depth):
++ '''Enter or add new bind in the next stack level.'''
++
++ if self.depth != depth:
++ if bind not in self.stack_binds:
++ self.stack_binds.append(bind)
++
++ return
++
++ mode = self.uzbl_config.get('mode', None)
++ if mode != 'stack':
++ self.last_mode = mode
++ self.uzbl_config['mode'] = 'stack'
++
++ self.stack_binds = [bind,]
++ self.args += args
++ self.depth += 1
++ self.after_cmds = bind.prompts[depth]
++
++
++ def after(self):
++ '''If a stack was triggered then set the prompt and default value.'''
++
++ if self.after_cmds is None:
++ return
++
++ (prompt, is_cmd, set), self.after_cmds = self.after_cmds, None
++
++ KeyCmd[self.uzbl].clear_keycmd()
++ if prompt:
++ self.uzbl_config['keycmd_prompt'] = prompt
++
++ if set and is_cmd:
++ self.uzbl.send(set)
++
++ elif set and not is_cmd:
++ self.uzbl.send('event SET_KEYCMD %s' % set)
++
++
++ def get_binds(self, mode=None):
++ '''Return the mode binds + globals. If we are stacked then return
++ the filtered stack list and modkey & non-stack globals.'''
++
++ if mode is None:
++ mode = self.uzbl_config.get('mode', None)
++
++ if not mode:
++ mode = 'global'
++
++ if self.depth:
++ return self.stack_binds + self.globals
++
++ globals = self.binds['global']
++ if mode not in self.binds or mode == 'global':
++ return [_f for _f in list(globals.values()) if _f]
++
++ binds = dict(list(globals.items()) + list(self.binds[mode].items()))
++ return [_f for _f in list(binds.values()) if _f]
++
++
++ def add_bind(self, mode, glob, bind=None):
++ '''Insert (or override) a bind into the mode bind dict.'''
++
++ if mode not in self.binds:
++ self.binds[mode] = {glob: bind}
++ return
++
++ binds = self.binds[mode]
++ binds[glob] = bind
++
++ if mode == 'global':
++ # Regen the global-globals list.
++ self.globals = []
++ for bind in list(binds.values()):
++ if bind is not None and bind.is_global:
++ self.globals.append(bind)
++
++
++def ismodbind(glob):
++ '''Return True if the glob specifies a modbind.'''
++
++ return bool(MOD_START(glob))
++
++
++def split_glob(glob):
++ '''Take a string of the form "<Mod1><Mod2>cmd _" and return a list of the
++ modkeys in the glob and the command.'''
++
++ mods = set()
++ while True:
++ match = MOD_START(glob)
++ if not match:
++ break
++
++ end = match.span()[1]
++ mods.add(glob[:end])
++ glob = glob[end:]
++
++ return (mods, glob)
++
++
++class Bind(object):
++
++ # unique id generator
++ nextid = count().__next__
++
++ def __init__(self, glob, handler, *args, **kargs):
++ self.is_callable = isinstance(handler, collections.Callable)
++ self._repr_cache = None
++
++ if not glob:
++ raise ArgumentError('glob cannot be blank')
++
++ if self.is_callable:
++ self.function = handler
++ self.args = args
++ self.kargs = kargs
++
++ elif kargs:
++ raise ArgumentError('cannot supply kargs for uzbl commands')
++
++ elif not isinstance(handler, str):
++ self.commands = handler
++
++ else:
++ self.commands = [handler,] + list(args)
++
++ self.glob = glob
++
++ # Assign unique id.
++ self.bid = self.nextid()
++
++ self.split = split = FIND_PROMPTS(glob)
++ self.prompts = []
++ for (prompt, cmd, set) in zip(split[1::4], split[2::4], split[3::4]):
++ prompt, set = list(map(unquote, [prompt, set]))
++ cmd = True if cmd == '!' else False
++ if prompt and prompt[-1] != ":":
++ prompt = "%s:" % prompt
++
++ self.prompts.append((prompt, cmd, set))
++
++ # Check that there is nothing like: fl*<int:>*
++ for glob in split[:-1:4]:
++ if glob.endswith('*'):
++ msg = "token '*' not at the end of a prompt bind: %r" % split
++ raise SyntaxError(msg)
++
++ # Check that there is nothing like: fl<prompt1:><prompt2:>_
++ for glob in split[4::4]:
++ if not glob:
++ msg = 'found null segment after first prompt: %r' % split
++ raise SyntaxError(msg)
++
++ stack = []
++ for (index, glob) in enumerate(reversed(split[::4])):
++ # Is the binding a MODCMD or KEYCMD:
++ mod_cmd = ismodbind(glob)
++
++ # Do we execute on UPDATES or EXEC events?
++ on_exec = True if glob[-1] in ['!', '_'] else False
++
++ # Does the command take arguments?
++ has_args = True if glob[-1] in ['*', '_'] else False
++
++ glob = glob[:-1] if has_args or on_exec else glob
++ mods, glob = split_glob(glob)
++ stack.append((on_exec, has_args, mods, glob, index))
++
++ self.stack = list(reversed(stack))
++ self.is_global = (len(self.stack) == 1 and self.stack[0][MOD_CMD])
++
++
++ def __getitem__(self, depth):
++ '''Get bind info at a depth.'''
++
++ if self.is_global:
++ return self.stack[0]
++
++ return self.stack[depth]
++
++
++ def __repr__(self):
++ if self._repr_cache:
++ return self._repr_cache
++
++ args = ['glob=%r' % self.glob, 'bid=%d' % self.bid]
++
++ if self.is_callable:
++ args.append('function=%r' % self.function)
++ if self.args:
++ args.append('args=%r' % self.args)
++
++ if self.kargs:
++ args.append('kargs=%r' % self.kargs)
++
++ else:
++ cmdlen = len(self.commands)
++ cmds = self.commands[0] if cmdlen == 1 else self.commands
++ args.append('command%s=%r' % ('s' if cmdlen-1 else '', cmds))
++
++ self._repr_cache = '<Bind(%s)>' % ', '.join(args)
++ return self._repr_cache
++
++
++class BindPlugin(PerInstancePlugin):
++ def __init__(self, uzbl):
++ '''Export functions and connect handlers to events.'''
++ super(BindPlugin, self).__init__(uzbl)
++
++ self.bindlet = Bindlet(uzbl)
++
++ uzbl.connect('BIND', self.parse_bind)
++ uzbl.connect('MODE_BIND', self.parse_mode_bind)
++ uzbl.connect('MODE_CHANGED', self.mode_changed)
++
++ # Connect key related events to the key_event function.
++ events = [['KEYCMD_UPDATE', 'KEYCMD_EXEC'],
++ ['MODCMD_UPDATE', 'MODCMD_EXEC']]
++
++ for mod_cmd in range(2):
++ for on_exec in range(2):
++ event = events[mod_cmd][on_exec]
++ handler = partial(self.key_event,
++ mod_cmd=bool(mod_cmd),
++ on_exec=bool(on_exec))
++ uzbl.connect(event, handler)
++
++ def exec_bind(self, bind, *args, **kargs):
++ '''Execute bind objects.'''
++
++ self.uzbl.event("EXEC_BIND", bind, args, kargs)
++
++ if bind.is_callable:
++ args += bind.args
++ kargs = dict(list(bind.kargs.items())+list(kargs.items()))
++ bind.function(self.uzbl, *args, **kargs)
++ return
++
++ if kargs:
++ raise ArgumentError('cannot supply kargs for uzbl commands')
++
++ commands = []
++ for cmd in bind.commands:
++ cmd = cmd_expand(cmd, args)
++ self.uzbl.send(cmd)
++
++ def mode_bind(self, modes, glob, handler=None, *args, **kargs):
++ '''Add a mode bind.'''
++
++ bindlet = self.bindlet
++
++ if isinstance(modes, str):
++ modes = modes.split(',')
++
++ # Sort and filter binds.
++ modes = [_f for _f in map(str.strip, modes) if _f]
++
++ if isinstance(handler, collections.Callable) or (handler is not None and handler.strip()):
++ bind = Bind(glob, handler, *args, **kargs)
++
++ else:
++ bind = None
++
++ for mode in modes:
++ if not VALID_MODE(mode):
++ raise NameError('invalid mode name: %r' % mode)
++
++ for mode in modes:
++ if mode[0] == '-':
++ mode, bind = mode[1:], None
++
++ bindlet.add_bind(mode, glob, bind)
++ self.uzbl.event('ADDED_MODE_BIND', mode, glob, bind)
++ self.logger.info('added bind %s %s %s', mode, glob, bind)
++
++ def bind(self, glob, handler, *args, **kargs):
++ '''Legacy bind function.'''
++
++ self.mode_bind('global', glob, handler, *args, **kargs)
++
++ def parse_mode_bind(self, args):
++ '''Parser for the MODE_BIND event.
++
++ Example events:
++ MODE_BIND <mode> <bind> = <command>
++ MODE_BIND command o<location:>_ = uri %s
++ MODE_BIND insert,command <BackSpace> = ...
++ MODE_BIND global ... = ...
++ MODE_BIND global,-insert ... = ...
++ '''
++
++ args = splitquoted(args)
++ if len(args) < 2:
++ raise ArgumentError('missing mode or bind section: %r' % args.raw())
++
++ modes = args[0].split(',')
++ for i, g in enumerate(args[1:]):
++ if g == '=':
++ glob = args.raw(1, i)
++ command = args.raw(i+2)
++ break
++ else:
++ raise ArgumentError('missing delimiter in bind section: %r' % args.raw())
++
++ self.mode_bind(modes, glob, command)
++
++ def parse_bind(self, args):
++ '''Legacy parsing of the BIND event and conversion to the new format.
++
++ Example events:
++ request BIND <bind> = <command>
++ request BIND o<location:>_ = uri %s
++ request BIND <BackSpace> = ...
++ request BIND ... = ...
++ '''
++
++ self.parse_mode_bind("global %s" % args)
++
++ def mode_changed(self, mode):
++ '''Clear the stack on all non-stack mode changes.'''
++
++ if mode != 'stack':
++ self.bindlet.reset()
++
++ def match_and_exec(self, bind, depth, modstate, keylet, bindlet):
++ (on_exec, has_args, mod_cmd, glob, more) = bind[depth]
++ cmd = keylet.modcmd if mod_cmd else keylet.keycmd
++
++ if mod_cmd and modstate != mod_cmd:
++ return False
++
++ if has_args:
++ if not cmd.startswith(glob):
++ return False
++
++ args = [cmd[len(glob):],]
++
++ elif cmd != glob:
++ return False
++
++ else:
++ args = []
++
++ if bind.is_global or (not more and depth == 0):
++ self.exec_bind(bind, *args)
++ if not has_args:
++ KeyCmd[self.uzbl].clear_current()
++
++ return True
++
++ elif more:
++ bindlet.stack(bind, args, depth)
++ (on_exec, has_args, mod_cmd, glob, more) = bind[depth+1]
++ if not on_exec and has_args and not glob and not more:
++ self.exec_bind(uzbl, bind, *(args+['',]))
++
++ return False
++
++ args = bindlet.args + args
++ self.exec_bind(bind, *args)
++ if not has_args or on_exec:
++ config = Config[self.uzbl]
++ del config['mode']
++ bindlet.reset()
++
++ return True
++
++ def key_event(self, modstate, keylet, mod_cmd=False, on_exec=False):
++ bindlet = self.bindlet
++ depth = bindlet.depth
++ for bind in bindlet.get_binds():
++ t = bind[depth]
++ if (bool(t[MOD_CMD]) != mod_cmd) or (t[ON_EXEC] != on_exec):
++ continue
++
++ if self.match_and_exec(bind, depth, modstate, keylet, bindlet):
++ return
++
++ bindlet.after()
++
++ # Return to the previous mode if the KEYCMD_EXEC keycmd doesn't match any
++ # binds in the stack mode.
++ if on_exec and not mod_cmd and depth and depth == bindlet.depth:
++ config = Config[uzbl]
++ del config['mode']
++
++# vi: set et ts=4:
+diff --git a/uzbl/plugins/cmd_expand.py b/uzbl/plugins/cmd_expand.py
+new file mode 100644
+index 0000000..46e1e67
+--- /dev/null
++++ b/uzbl/plugins/cmd_expand.py
+@@ -0,0 +1,36 @@
++def escape(str):
++ for (level, char) in [(3, '\\'), (2, "'"), (2, '"'), (1, '@')]:
++ str = str.replace(char, (level * '\\') + char)
++
++ return str
++
++
++def cmd_expand(cmd, args):
++ '''Exports a function that provides the following
++ expansions in any uzbl command string:
++
++ %s = replace('%s', ' '.join(args))
++ %r = replace('%r', "'%s'" % escaped(' '.join(args)))
++ %1 = replace('%1', arg[0])
++ %2 = replace('%2', arg[1])
++ %n = replace('%n', arg[n-1])
++ '''
++
++ # Ensure (1) all string representable and (2) correct string encoding.
++ args = list(map(str, args))
++
++ # Direct string replace.
++ if '%s' in cmd:
++ cmd = cmd.replace('%s', ' '.join(args))
++
++ # Escaped and quoted string replace.
++ if '%r' in cmd:
++ cmd = cmd.replace('%r', "'%s'" % escape(' '.join(args)))
++
++ # Arg index string replace.
++ for (index, arg) in enumerate(args):
++ index += 1
++ if '%%%d' % index in cmd:
++ cmd = cmd.replace('%%%d' % index, str(arg))
++
++ return cmd
+diff --git a/uzbl/plugins/completion.py b/uzbl/plugins/completion.py
+new file mode 100644
+index 0000000..ef2f277
+--- /dev/null
++++ b/uzbl/plugins/completion.py
+@@ -0,0 +1,186 @@
++'''Keycmd completion.'''
++
++import re
++
++from uzbl.arguments import splitquoted
++from uzbl.ext import PerInstancePlugin
++from .config import Config
++from .keycmd import KeyCmd
++
++# Completion level
++NONE, ONCE, LIST, COMPLETE = list(range(4))
++
++# The reverse keyword finding re.
++FIND_SEGMENT = re.compile("(\@[\w_]+|set[\s]+[\w_]+|[\w_]+)$").findall
++
++
++def escape(str):
++ return str.replace("@", "\@")
++
++
++class Completions(set):
++ def __init__(self):
++ set.__init__(self)
++ self.locked = False
++ self.level = NONE
++
++ def lock(self):
++ self.locked = True
++
++ def unlock(self):
++ self.locked = False
++
++ def add_var(self, var):
++ self.add('@' + var)
++
++
++class CompletionListFormatter(object):
++ LIST_FORMAT = "<span> %s </span>"
++ ITEM_FORMAT = "<span @hint_style>%s</span>%s"
++
++ def format(self, partial, completions):
++ p = len(partial)
++ completions.sort()
++ return self.LIST_FORMAT % ' '.join(
++ [self.ITEM_FORMAT % (escape(h[:p]), h[p:]) for h in completions]
++ )
++
++
++class CompletionPlugin(PerInstancePlugin):
++ def __init__(self, uzbl):
++ '''Export functions and connect handlers to events.'''
++ super(CompletionPlugin, self).__init__(uzbl)
++
++ self.completion = Completions()
++ self.listformatter = CompletionListFormatter()
++
++ uzbl.connect('BUILTINS', self.add_builtins)
++ uzbl.connect('CONFIG_CHANGED', self.add_config_key)
++ uzbl.connect('KEYCMD_CLEARED', self.stop_completion)
++ uzbl.connect('KEYCMD_EXEC', self.stop_completion)
++ uzbl.connect('KEYCMD_UPDATE', self.update_completion_list)
++ uzbl.connect('START_COMPLETION', self.start_completion)
++ uzbl.connect('STOP_COMPLETION', self.stop_completion)
++
++ uzbl.send('dump_config_as_events')
++
++ def get_incomplete_keyword(self):
++ '''Gets the segment of the keycmd leading up to the cursor position and
++ uses a regular expression to search backwards finding parially completed
++ keywords or @variables. Returns a null string if the correct completion
++ conditions aren't met.'''
++
++ keylet = KeyCmd[self.uzbl].keylet
++ left_segment = keylet.keycmd[:keylet.cursor]
++ partial = (FIND_SEGMENT(left_segment) + ['', ])[0].lstrip()
++ if partial.startswith('set '):
++ return ('@' + partial[4:].lstrip(), True)
++
++ return (partial, False)
++
++ def stop_completion(self, *args):
++ '''Stop command completion and return the level to NONE.'''
++
++ self.completion.level = NONE
++ if 'completion_list' in Config[self.uzbl]:
++ del Config[self.uzbl]['completion_list']
++
++ def complete_completion(self, partial, hint, set_completion=False):
++ '''Inject the remaining porition of the keyword into the keycmd then stop
++ the completioning.'''
++
++ if set_completion:
++ remainder = "%s = " % hint[len(partial):]
++
++ else:
++ remainder = "%s " % hint[len(partial):]
++
++ KeyCmd[self.uzbl].inject_keycmd(remainder)
++ self.stop_completion()
++
++ def partial_completion(self, partial, hint):
++ '''Inject a common portion of the hints into the keycmd.'''
++
++ remainder = hint[len(partial):]
++ KeyCmd[self.uzbl].inject_keycmd(remainder)
++
++ def update_completion_list(self, *args):
++ '''Checks if the user still has a partially completed keyword under his
++ cursor then update the completion hints list.'''
++
++ partial = self.get_incomplete_keyword()[0]
++ if not partial:
++ return self.stop_completion()
++
++ if self.completion.level < LIST:
++ return
++
++ config = Config[self.uzbl]
++
++ hints = [h for h in self.completion if h.startswith(partial)]
++ if not hints:
++ del config['completion_list']
++ return
++
++ config['completion_list'] = self.listformatter.format(partial, hints)
++
++ def start_completion(self, *args):
++ if self.completion.locked:
++ return
++
++ (partial, set_completion) = self.get_incomplete_keyword()
++ if not partial:
++ return self.stop_completion()
++
++ if self.completion.level < COMPLETE:
++ self.completion.level += 1
++
++ hints = [h for h in self.completion if h.startswith(partial)]
++ if not hints:
++ return
++
++ elif len(hints) == 1:
++ self.completion.lock()
++ self.complete_completion(partial, hints[0], set_completion)
++ self.completion.unlock()
++ return
++
++ elif partial in hints and completion.level == COMPLETE:
++ self.completion.lock()
++ self.complete_completion(partial, partial, set_completion)
++ self.completion.unlock()
++ return
++
++ smalllen, smallest = sorted([(len(h), h) for h in hints])[0]
++ common = ''
++ for i in range(len(partial), smalllen):
++ char, same = smallest[i], True
++ for hint in hints:
++ if hint[i] != char:
++ same = False
++ break
++
++ if not same:
++ break
++
++ common += char
++
++ if common:
++ self.completion.lock()
++ self.partial_completion(partial, partial + common)
++ self.completion.unlock()
++
++ self.update_completion_list()
++
++ def add_builtins(self, builtins):
++ '''Pump the space delimited list of builtin commands into the
++ builtin list.'''
++
++ builtins = splitquoted(builtins)
++ self.completion.update(builtins)
++
++ def add_config_key(self, key, value):
++ '''Listen on the CONFIG_CHANGED event and add config keys to the variable
++ list for @var<Tab> like expansion support.'''
++
++ self.completion.add_var(key)
+diff --git a/uzbl/plugins/config.py b/uzbl/plugins/config.py
+new file mode 100644
+index 0000000..4f00315
+--- /dev/null
++++ b/uzbl/plugins/config.py
+@@ -0,0 +1,109 @@
++from re import compile
++
++from uzbl.arguments import splitquoted
++from uzbl.ext import PerInstancePlugin
++
++types = {'int': int, 'float': float, 'str': str}
++
++valid_key = compile('^[A-Za-z0-9_\.]+$').match
++
++class Config(PerInstancePlugin):
++ """Configuration plugin, has dictionary interface for config access
++
++ This class is currenty not inherited from either UserDict or abc.Mapping
++ because not sure what version of python we want to support. It's not
++ hard to implement all needed methods either.
++ """
++
++ def __init__(self, uzbl):
++ super(Config, self).__init__(uzbl)
++
++ self.data = {}
++ uzbl.connect('VARIABLE_SET', self.parse_set_event)
++ assert not 'a' in self.data
++
++ def __getitem__(self, key):
++ return self.data[key]
++
++ def __setitem__(self, key, value):
++ self.set(key, value)
++
++ def __delitem__(self, key):
++ self.set(key)
++
++ def get(self, key, default=None):
++ return self.data.get(key, default)
++
++ def __contains__(self, key):
++ return key in self.data
++
++ def keys(self):
++ return iter(self.data.keys())
++
++ def items(self):
++ return iter(self.data.items())
++
++ def update(self, other=None, **kwargs):
++ if other is None:
++ other = {}
++
++ for (key, value) in list(dict(other).items()) + list(kwargs.items()):
++ self[key] = value
++
++
++ def set(self, key, value='', force=False):
++ '''Generates a `set <key> = <value>` command string to send to the
++ current uzbl instance.
++
++ Note that the config dict isn't updated by this function. The config
++ dict is only updated after a successful `VARIABLE_SET ..` event
++ returns from the uzbl instance.'''
++
++ assert valid_key(key)
++
++ if isinstance(value, bool):
++ value = int(value)
++
++ else:
++ value = str(value)
++ assert '\n' not in value
++
++ if not force and key in self and self[key] == value:
++ return
++
++ self.uzbl.send('set %s = %s' % (key, value))
++
++
++ def parse_set_event(self, args):
++ '''Parse `VARIABLE_SET <var> <type> <value>` event and load the
++ (key, value) pair into the `uzbl.config` dict.'''
++
++ args = splitquoted(args)
++ if len(args) == 2:
++ key, type, raw_value = args[0], args[1], ''
++ elif len(args) == 3:
++ key, type, raw_value = args
++ else:
++ raise Exception('Invalid number of arguments')
++
++ assert valid_key(key)
++ assert type in types
++
++ new_value = types[type](raw_value)
++ old_value = self.data.get(key, None)
++
++ # Update new value.
++ self.data[key] = new_value
++
++ if old_value != new_value:
++ self.uzbl.event('CONFIG_CHANGED', key, new_value)
++
++ # Cleanup null config values.
++ if type == 'str' and not new_value:
++ del self.data[key]
++
++ def cleanup(self):
++ # not sure it's needed, but safer for cyclic links
++ self.data.clear()
++ super(Config, self).cleanup()
++
+diff --git a/uzbl/plugins/cookies.py b/uzbl/plugins/cookies.py
+new file mode 100644
+index 0000000..8875e99
+--- /dev/null
++++ b/uzbl/plugins/cookies.py
+@@ -0,0 +1,226 @@
++""" Basic cookie manager
++ forwards cookies to all other instances connected to the event manager"""
++
++from collections import defaultdict
++import os, re, stat
++
++from uzbl.arguments import splitquoted
++from uzbl.ext import GlobalPlugin, PerInstancePlugin
++
++# these are symbolic names for the components of the cookie tuple
++symbolic = {'domain': 0, 'path':1, 'name':2, 'value':3, 'scheme':4, 'expires':5}
++
++# allows for partial cookies
++# ? allow wildcard in key
++def match(key, cookie):
++ for k,c in zip(key,cookie):
++ if k != c:
++ return False
++ return True
++
++def match_list(_list, cookie):
++ for matcher in _list:
++ for component, match in matcher:
++ if match(cookie[component]) is None:
++ break
++ else:
++ return True
++ return False
++
++def add_cookie_matcher(_list, arg):
++ ''' add a cookie matcher to a whitelist or a blacklist.
++ a matcher is a list of (component, re) tuples that matches a cookie when the
++ "component" part of the cookie matches the regular expression "re".
++ "component" is one of the keys defined in the variable "symbolic" above,
++ or the index of a component of a cookie tuple.
++ '''
++
++ args = splitquoted(arg)
++ mlist = []
++ for (component, regexp) in zip(args[0::2], args[1::2]):
++ try:
++ component = symbolic[component]
++ except KeyError:
++ component = int(component)
++ assert component <= 5
++ mlist.append((component, re.compile(regexp).search))
++ _list.append(mlist)
++
++class NullStore(object):
++ def add_cookie(self, rawcookie, cookie):
++ pass
++
++ def delete_cookie(self, rkey, key):
++ pass
++
++class ListStore(list):
++ def add_cookie(self, rawcookie, cookie):
++ self.append(rawcookie)
++
++ def delete_cookie(self, rkey, key):
++ self[:] = [x for x in self if not match(key, splitquoted(x))]
++
++class TextStore(object):
++ def __init__(self, filename):
++ self.filename = filename
++ try:
++ # make sure existing cookie jar is not world-open
++ perm_mode = os.stat(self.filename).st_mode
++ if (perm_mode & (stat.S_IRWXO | stat.S_IRWXG)) > 0:
++ safe_perm = stat.S_IMODE(perm_mode) & ~(stat.S_IRWXO | stat.S_IRWXG)
++ os.chmod(self.filename, safe_perm)
++ except OSError:
++ pass
++
++ def as_event(self, cookie):
++ """Convert cookie.txt row to uzbls cookie event format"""
++ scheme = {
++ 'TRUE' : 'https',
++ 'FALSE' : 'http'
++ }
++ extra = ''
++ if cookie[0].startswith("#HttpOnly_"):
++ extra = 'Only'
++ domain = cookie[0][len("#HttpOnly_"):]
++ elif cookie[0].startswith('#'):
++ return None
++ else:
++ domain = cookie[0]
++ try:
++ return (domain,
++ cookie[2],
++ cookie[5],
++ cookie[6],
++ scheme[cookie[3]] + extra,
++ cookie[4])
++ except (KeyError,IndexError):
++ # Let malformed rows pass through like comments
++ return None
++
++ def as_file(self, cookie):
++ """Convert cookie event to cookie.txt row"""
++ secure = {
++ 'https' : 'TRUE',
++ 'http' : 'FALSE',
++ 'httpsOnly' : 'TRUE',
++ 'httpOnly' : 'FALSE'
++ }
++ http_only = {
++ 'https' : '',
++ 'http' : '',
++ 'httpsOnly' : '#HttpOnly_',
++ 'httpOnly' : '#HttpOnly_'
++ }
++ return (http_only[cookie[4]] + cookie[0],
++ 'TRUE' if cookie[0].startswith('.') else 'FALSE',
++ cookie[1],
++ secure[cookie[4]],
++ cookie[5],
++ cookie[2],
++ cookie[3])
++
++ def add_cookie(self, rawcookie, cookie):
++ assert len(cookie) == 6
++
++ # delete equal cookies (ignoring expire time, value and secure flag)
++ self.delete_cookie(None, cookie[:-3])
++
++ # restrict umask before creating the cookie jar
++ curmask=os.umask(0)
++ os.umask(curmask| stat.S_IRWXO | stat.S_IRWXG)
++
++ first = not os.path.exists(self.filename)
++ with open(self.filename, 'a') as f:
++ if first:
++ print("# HTTP Cookie File", file=f)
++ print('\t'.join(self.as_file(cookie)), file=f)
++
++ def delete_cookie(self, rkey, key):
++ if not os.path.exists(self.filename):
++ return
++
++ # restrict umask before creating the cookie jar
++ curmask=os.umask(0)
++ os.umask(curmask | stat.S_IRWXO | stat.S_IRWXG)
++
++ # read all cookies
++ with open(self.filename, 'r') as f:
++ cookies = f.readlines()
++
++ # write those that don't match the cookie to delete
++ with open(self.filename, 'w') as f:
++ for l in cookies:
++ c = self.as_event(l.split('\t'))
++ if c is None or not match(key, c):
++ print(l, end='', file=f)
++ os.umask(curmask)
++
++xdg_data_home = os.environ.get('XDG_DATA_HOME', os.path.join(os.environ['HOME'], '.local/share'))
++DefaultStore = TextStore(os.path.join(xdg_data_home, 'uzbl/cookies.txt'))
++SessionStore = TextStore(os.path.join(xdg_data_home, 'uzbl/session-cookies.txt'))
++
++class Cookies(PerInstancePlugin):
++ def __init__(self, uzbl):
++ super(Cookies, self).__init__(uzbl)
++
++ self.whitelist = []
++ self.blacklist = []
++
++ uzbl.connect('ADD_COOKIE', self.add_cookie)
++ uzbl.connect('DELETE_COOKIE', self.delete_cookie)
++ uzbl.connect('BLACKLIST_COOKIE', self.blacklist_cookie)
++ uzbl.connect('WHITELIST_COOKIE', self.whitelist_cookie)
++
++ # accept a cookie only when:
++ # a. there is no whitelist and the cookie is in the blacklist
++ # b. the cookie is in the whitelist and not in the blacklist
++ def accept_cookie(self, cookie):
++ if self.whitelist:
++ if match_list(self.whitelist, cookie):
++ return not match_list(self.blacklist, cookie)
++ return False
++
++ return not match_list(self.blacklist, cookie)
++
++ def expires_with_session(self, cookie):
++ return cookie[5] == ''
++
++ def get_recipents(self):
++ """ get a list of Uzbl instances to send the cookie too. """
++ # This could be a lot more interesting
++ return [u for u in list(self.uzbl.parent.uzbls.values()) if u is not self.uzbl]
++
++ def get_store(self, session=False):
++ if session:
++ return SessionStore
++ return DefaultStore
++
++ def add_cookie(self, cookie):
++ cookie = splitquoted(cookie)
++ if self.accept_cookie(cookie):
++ for u in self.get_recipents():
++ u.send('add_cookie %s' % cookie.raw())
++
++ self.get_store(self.expires_with_session(cookie)).add_cookie(cookie.raw(), cookie)
++ else:
++ self.logger.debug('cookie %r is blacklisted', cookie)
++ self.uzbl.send('delete_cookie %s' % cookie.raw())
++
++ def delete_cookie(self, cookie):
++ cookie = splitquoted(cookie)
++ for u in self.get_recipents():
++ u.send('delete_cookie %s' % cookie.raw())
++
++ if len(cookie) == 6:
++ self.get_store(self.expires_with_session(cookie)).delete_cookie(cookie.raw(), cookie)
++ else:
++ for store in set([self.get_store(session) for session in (True, False)]):
++ store.delete_cookie(cookie.raw(), cookie)
++
++ def blacklist_cookie(self, arg):
++ add_cookie_matcher(self.blacklist, arg)
++
++ def whitelist_cookie(self, arg):
++ add_cookie_matcher(self.whitelist, arg)
++
++# vi: set et ts=4:
+diff --git a/uzbl/plugins/downloads.py b/uzbl/plugins/downloads.py
+new file mode 100644
+index 0000000..208dbda
+--- /dev/null
++++ b/uzbl/plugins/downloads.py
+@@ -0,0 +1,83 @@
++# this plugin does a very simple display of download progress. to use it, add
++# @downloads to your status_format.
++
++import os
++import html
++
++from uzbl.arguments import splitquoted
++from .config import Config
++from uzbl.ext import PerInstancePlugin
++
++class Downloads(PerInstancePlugin):
++
++ def __init__(self, uzbl):
++ super(Downloads, self).__init__(uzbl)
++ uzbl.connect('DOWNLOAD_STARTED', self.download_started)
++ uzbl.connect('DOWNLOAD_PROGRESS', self.download_progress)
++ uzbl.connect('DOWNLOAD_COMPLETE', self.download_complete)
++ self.active_downloads = {}
++
++ def update_download_section(self):
++ """after a download's status has changed this
++ is called to update the status bar
++ """
++
++ if self.active_downloads:
++ # add a newline before we list downloads
++ result = ' downloads:'
++ for path, progress in list(self.active_downloads.items()):
++ # add each download
++ fn = os.path.basename(path)
++
++ dl = " %s (%d%%)" % (fn, progress * 100)
++
++ # replace entities to make sure we don't break our markup
++ # (this could be done with an @[]@ expansion in uzbl, but then we
++ # can't use the above to make a new line)
++ dl = html.escape(dl)
++ result += dl
++ else:
++ result = ''
++
++ # and the result gets saved to an uzbl variable that can be used in
++ # status_format
++ config = Config[self.uzbl]
++ if config.get('downloads', '') != result:
++ config['downloads'] = result
++
++ def download_started(self, args):
++ # parse the arguments
++ args = splitquoted(args)
++ destination_path = args[0]
++
++ # add to the list of active downloads
++ self.active_downloads[destination_path] = 0.0
++
++ # update the progress
++ self.update_download_section()
++
++ def download_progress(self, args):
++ # parse the arguments
++ args = splitquoted(args)
++ destination_path = args[0]
++ progress = float(args[1])
++
++ # update the progress
++ self.active_downloads[destination_path] = progress
++
++ # update the status bar variable
++ self.update_download_section()
++
++ def download_complete(self, args):
++ # TODO(tailhook) be more userfriendly: show download for some time!
++
++ # parse the arguments
++ args = splitquoted(args)
++ destination_path = args[0]
++
++ # remove from the list of active downloads
++ del self.active_downloads[destination_path]
++
++ # update the status bar variable
++ self.update_download_section()
++
+diff --git a/uzbl/plugins/history.py b/uzbl/plugins/history.py
+new file mode 100644
+index 0000000..1a0e0fb
+--- /dev/null
++++ b/uzbl/plugins/history.py
+@@ -0,0 +1,148 @@
++import random
++
++from .on_set import OnSetPlugin
++from .keycmd import KeyCmd
++from uzbl.ext import GlobalPlugin, PerInstancePlugin
++
++class SharedHistory(GlobalPlugin):
++
++ def __init__(self, event_manager):
++ super(SharedHistory, self).__init__(event_manager)
++ self.history = {} #TODO(tailhook) save and load from file
++
++ def get_line_number(self, prompt):
++ try:
++ return len(self.history[prompt])
++ except KeyError:
++ return 0
++
++ def addline(self, prompt, entry):
++ lst = self.history.get(prompt)
++ if lst is None:
++ self.history[prompt] = [entry]
++ else:
++ lst.append(entry)
++
++ def getline(self, prompt, index):
++ try:
++ return self.history[prompt][index]
++ except KeyError:
++ # not existent list is same as empty one
++ raise IndexError()
++
++
++class History(PerInstancePlugin):
++
++ def __init__(self, uzbl):
++ super(History, self).__init__(uzbl)
++ self._tail = ''
++ self.prompt = ''
++ self.cursor = None
++ self.search_key = None
++ uzbl.connect('KEYCMD_EXEC', self.keycmd_exec)
++ uzbl.connect('HISTORY_PREV', self.history_prev)
++ uzbl.connect('HISTORY_NEXT', self.history_next)
++ uzbl.connect('HISTORY_SEARCH', self.history_search)
++ OnSetPlugin[uzbl].on_set('keycmd_prompt',
++ lambda uzbl, k, v: self.change_prompt(v))
++
++ def prev(self):
++ shared = SharedHistory[self.uzbl]
++ if self.cursor is None:
++ self.cursor = shared.get_line_number(self.prompt) - 1
++ else:
++ self.cursor -= 1
++
++ if self.search_key:
++ while self.cursor >= 0:
++ line = shared.getline(self.prompt, self.cursor)
++ if self.search_key in line:
++ return line
++ self.cursor -= 1
++
++ if self.cursor >= 0:
++ return shared.getline(self.prompt, self.cursor)
++
++ self.cursor = -1
++ return random.choice(end_messages)
++
++ def __next__(self):
++ if self.cursor is None:
++ return ''
++ shared = SharedHistory[self.uzbl]
++
++ self.cursor += 1
++
++ num = shared.get_line_number(self.prompt)
++ if self.search_key:
++ while self.cursor < num:
++ line = shared.getline(self.prompt, self.cursor)
++ if self.search_key in line:
++ return line
++ self.cursor += 1
++
++ if self.cursor >= num:
++ self.cursor = None
++ self.search_key = None
++ if self._tail:
++ value = self._tail
++ self._tail = None
++ return value
++ return ''
++ return shared.getline(self.prompt, self.cursor)
++
++ def change_prompt(self, prompt):
++ self.prompt = prompt
++ self._tail = None
++
++ def search(self, key):
++ self.search_key = key
++ self.cursor = None
++
++ def __str__(self):
++ return "(History %s, %s)" % (self.cursor, self.prompt)
++
++ def keycmd_exec(self, modstate, keylet):
++ cmd = keylet.get_keycmd()
++ if cmd:
++ SharedHistory[self.uzbl].addline(self.prompt, cmd)
++ self._tail = None
++ self.cursor = None
++ self.search_key = None
++
++ def history_prev(self, _x):
++ cmd = KeyCmd[self.uzbl].keylet.get_keycmd()
++ if self.cursor is None and cmd:
++ self._tail = cmd
++ val = self.prev()
++ KeyCmd[self.uzbl].set_keycmd(val)
++
++ def history_next(self, _x):
++ KeyCmd[self.uzbl].set_keycmd(next(self))
++
++ def history_search(self, key):
++ self.search(key)
++ self.uzbl.send('event HISTORY_PREV')
++
++end_messages = (
++ 'Look behind you, A three-headed monkey!',
++ 'error #4: static from nylon underwear.',
++ 'error #5: static from plastic slide rules.',
++ 'error #6: global warming.',
++ 'error #9: doppler effect.',
++ 'error #16: somebody was calculating pi on the server.',
++ 'error #19: floating point processor overflow.',
++ 'error #21: POSIX compliance problem.',
++ 'error #25: Decreasing electron flux.',
++ 'error #26: first Saturday after first full moon in Winter.',
++ 'error #64: CPU needs recalibration.',
++ 'error #116: the real ttys became pseudo ttys and vice-versa.',
++ 'error #229: wrong polarity of neutron flow.',
++ 'error #330: quantum decoherence.',
++ 'error #388: Bad user karma.',
++ 'error #407: Route flapping at the NAP.',
++ 'error #435: Internet shut down due to maintenance.',
++ )
++
++
++# vi: set et ts=4:
+diff --git a/uzbl/plugins/keycmd.py b/uzbl/plugins/keycmd.py
+new file mode 100644
+index 0000000..2020fda
+--- /dev/null
++++ b/uzbl/plugins/keycmd.py
+@@ -0,0 +1,503 @@
++import re
++
++from uzbl.arguments import splitquoted
++from uzbl.ext import PerInstancePlugin
++from .config import Config
++
++# Keycmd format which includes the markup for the cursor.
++KEYCMD_FORMAT = "%s<span @cursor_style>%s</span>%s"
++MODCMD_FORMAT = "<span> %s </span>"
++
++
++# FIXME, add utility functions to shared module
++def escape(str):
++ for char in ['\\', '@']:
++ str = str.replace(char, '\\'+char)
++
++ return str
++
++
++def uzbl_escape(str):
++ return "@[%s]@" % escape(str) if str else ''
++
++
++def inject_str(str, index, inj):
++ '''Inject a string into string at at given index.'''
++
++ return "%s%s%s" % (str[:index], inj, str[index:])
++
++
++class Keylet(object):
++ '''Small per-instance object that tracks characters typed.
++
++ >>> k = Keylet()
++ >>> k.set_keycmd('spam')
++ >>> print(k)
++ <keylet(keycmd='spam')>
++ >>> k.append_keycmd(' and egg')
++ >>> print(k)
++ <keylet(keycmd='spam and egg')>
++ >>> print(k.cursor)
++ 12
++ '''
++
++ def __init__(self):
++ # Modcmd tracking
++ self.modcmd = ''
++ self.is_modcmd = False
++
++ # Keycmd tracking
++ self.keycmd = ''
++ self.cursor = 0
++
++ def get_keycmd(self):
++ ''' Get the keycmd-part of the keylet. '''
++
++ return self.keycmd
++
++ def clear_keycmd(self):
++ ''' Clears the keycmd part of the keylet '''
++
++ self.keycmd = ''
++ self.cursor = 0
++
++ def get_modcmd(self):
++ ''' Get the modcmd-part of the keylet. '''
++
++ if not self.is_modcmd:
++ return ''
++
++ return self.modcmd
++
++ def clear_modcmd(self):
++ self.modcmd = ''
++ self.is_modcmd = False
++
++ def set_keycmd(self, keycmd):
++ self.keycmd = keycmd
++ self.cursor = len(keycmd)
++
++ def insert_keycmd(self, s):
++ ''' Inserts string at the current position
++
++ >>> k = Keylet()
++ >>> k.set_keycmd('spam')
++ >>> k.cursor = 1
++ >>> k.insert_keycmd('egg')
++ >>> print(k)
++ <keylet(keycmd='seggpam')>
++ >>> print(k.cursor)
++ 4
++ '''
++
++ self.keycmd = inject_str(self.keycmd, self.cursor, s)
++ self.cursor += len(s)
++
++ def append_keycmd(self, s):
++ ''' Appends string to to end of keycmd and moves the cursor
++
++ >>> k = Keylet()
++ >>> k.set_keycmd('spam')
++ >>> k.cursor = 1
++ >>> k.append_keycmd('egg')
++ >>> print(k)
++ <keylet(keycmd='spamegg')>
++ >>> print(k.cursor)
++ 7
++ '''
++
++ self.keycmd += s
++ self.cursor = len(self.keycmd)
++
++ def backspace(self):
++ ''' Removes the character at the cursor position. '''
++ if not self.keycmd or not self.cursor:
++ return False
++
++ self.keycmd = self.keycmd[:self.cursor-1] + self.keycmd[self.cursor:]
++ self.cursor -= 1
++ return True
++
++ def delete(self):
++ ''' Removes the character after the cursor position. '''
++ if not self.keycmd:
++ return False
++
++ self.keycmd = self.keycmd[:self.cursor] + self.keycmd[self.cursor+1:]
++ return True
++
++ def strip_word(self, seps=' '):
++ ''' Removes the last word from the keycmd, similar to readline ^W
++ returns the part removed or None
++
++ >>> k = Keylet()
++ >>> k.set_keycmd('spam and egg')
++ >>> k.strip_word()
++ 'egg'
++ >>> print(k)
++ <keylet(keycmd='spam and ')>
++ >>> k.strip_word()
++ 'and'
++ >>> print(k)
++ <keylet(keycmd='spam ')>
++ '''
++ if not self.keycmd:
++ return None
++
++ head, tail = self.keycmd[:self.cursor].rstrip(seps), self.keycmd[self.cursor:]
++ rfind = -1
++ for sep in seps:
++ p = head.rfind(sep)
++ if p >= 0 and rfind < p + 1:
++ rfind = p + 1
++ if rfind == len(head) and head[-1] in seps:
++ rfind -= 1
++ self.keycmd = head[:rfind] if rfind + 1 else '' + tail
++ self.cursor = len(head)
++ return head[rfind:]
++
++ def set_cursor_pos(self, index):
++ ''' Sets the cursor position, Supports negative indexing and relative
++ stepping with '+' and '-'.
++ Returns the new cursor position
++
++ >>> k = Keylet()
++ >>> k.set_keycmd('spam and egg')
++ >>> k.set_cursor_pos(2)
++ 2
++ >>> k.set_cursor_pos(-3)
++ 10
++ >>> k.set_cursor_pos('+')
++ 11
++ '''
++
++ if index == '-':
++ cursor = self.cursor - 1
++
++ elif index == '+':
++ cursor = self.cursor + 1
++
++ else:
++ cursor = int(index)
++ if cursor < 0:
++ cursor = len(self.keycmd) + cursor + 1
++
++ if cursor < 0:
++ cursor = 0
++
++ if cursor > len(self.keycmd):
++ cursor = len(self.keycmd)
++
++ self.cursor = cursor
++ return self.cursor
++
++ def markup(self):
++ ''' Returns the keycmd with the cursor in pango markup spliced in
++
++ >>> k = Keylet()
++ >>> k.set_keycmd('spam and egg')
++ >>> k.set_cursor_pos(4)
++ 4
++ >>> k.markup()
++ '@[spam]@<span @cursor_style>@[ ]@</span>@[and egg]@'
++ '''
++
++ if self.cursor < len(self.keycmd):
++ curchar = self.keycmd[self.cursor]
++ else:
++ curchar = ' '
++ chunks = [self.keycmd[:self.cursor], curchar, self.keycmd[self.cursor+1:]]
++ return KEYCMD_FORMAT % tuple(map(uzbl_escape, chunks))
++
++ def __repr__(self):
++ ''' Return a string representation of the keylet. '''
++
++ l = []
++ if self.is_modcmd:
++ l.append('modcmd=%r' % self.get_modcmd())
++
++ if self.keycmd:
++ l.append('keycmd=%r' % self.get_keycmd())
++
++ return '<keylet(%s)>' % ', '.join(l)
++
++
++class KeyCmd(PerInstancePlugin):
++ def __init__(self, uzbl):
++ '''Export functions and connect handlers to events.'''
++ super(KeyCmd, self).__init__(uzbl)
++
++ self.keylet = Keylet()
++ self.modmaps = {}
++ self.ignores = {}
++
++ uzbl.connect('APPEND_KEYCMD', self.append_keycmd)
++ uzbl.connect('IGNORE_KEY', self.add_key_ignore)
++ uzbl.connect('INJECT_KEYCMD', self.inject_keycmd)
++ uzbl.connect('KEYCMD_BACKSPACE', self.keycmd_backspace)
++ uzbl.connect('KEYCMD_DELETE', self.keycmd_delete)
++ uzbl.connect('KEYCMD_EXEC_CURRENT', self.keycmd_exec_current)
++ uzbl.connect('KEYCMD_STRIP_WORD', self.keycmd_strip_word)
++ uzbl.connect('KEYCMD_CLEAR', self.clear_keycmd)
++ uzbl.connect('KEY_PRESS', self.key_press)
++ uzbl.connect('KEY_RELEASE', self.key_release)
++ uzbl.connect('MOD_PRESS', self.key_press)
++ uzbl.connect('MOD_RELEASE', self.key_release)
++ uzbl.connect('MODMAP', self.modmap_parse)
++ uzbl.connect('SET_CURSOR_POS', self.set_cursor_pos)
++ uzbl.connect('SET_KEYCMD', self.set_keycmd)
++
++ def modmap_key(self, key):
++ '''Make some obscure names for some keys friendlier.'''
++
++ if key in self.modmaps:
++ return self.modmaps[key]
++
++ elif key.endswith('_L') or key.endswith('_R'):
++ # Remove left-right discrimination and try again.
++ return self.modmap_key(key[:-2])
++
++ else:
++ return key
++
++
++ def key_ignored(self, key):
++ '''Check if the given key is ignored by any ignore rules.'''
++
++ for (glob, match) in list(self.ignores.items()):
++ if match(key):
++ return True
++
++ return False
++
++ def add_modmap(self, key, map):
++ '''Add modmaps.
++
++ Examples:
++ set modmap = request MODMAP
++ @modmap <Control> <Ctrl>
++ @modmap <ISO_Left_Tab> <Shift-Tab>
++ ...
++
++ Then:
++ @bind <Shift-Tab> = <command1>
++ @bind <Ctrl>x = <command2>
++ ...
++
++ '''
++
++ assert len(key)
++ modmaps = self.modmaps
++
++ modmaps[key.strip('<>')] = map.strip('<>')
++ self.uzbl.event("NEW_MODMAP", key, map)
++
++ def modmap_parse(self, map):
++ '''Parse a modmap definiton.'''
++
++ split = splitquoted(map)
++
++ if not split or len(split) > 2:
++ raise Exception('Invalid modmap arugments: %r' % map)
++
++ self.add_modmap(*split)
++
++ def add_key_ignore(self, glob):
++ '''Add an ignore definition.
++
++ Examples:
++ set ignore_key = request IGNORE_KEY
++ @ignore_key <Shift>
++ @ignore_key <ISO_*>
++ ...
++ '''
++
++ assert len(glob) > 1
++ ignores = self.ignores
++
++ glob = "<%s>" % glob.strip("<> ")
++ restr = glob.replace('*', '[^\s]*')
++ match = re.compile(restr).match
++
++ ignores[glob] = match
++ self.uzbl.event('NEW_KEY_IGNORE', glob)
++
++ def clear_keycmd(self, *args):
++ '''Clear the keycmd for this uzbl instance.'''
++
++ self.keylet.clear_keycmd()
++ config = Config[self.uzbl]
++ del config['keycmd']
++ self.uzbl.event('KEYCMD_CLEARED')
++
++ def clear_modcmd(self):
++ '''Clear the modcmd for this uzbl instance.'''
++
++ self.keylet.clear_modcmd()
++
++ config = Config[self.uzbl]
++ del config['modcmd']
++ self.uzbl.event('MODCMD_CLEARED')
++
++ def clear_current(self):
++ '''Clear the modcmd if is_modcmd else clear keycmd.'''
++
++ if self.keylet.is_modcmd:
++ self.clear_modcmd()
++
++ else:
++ self.clear_keycmd()
++
++ def update_event(self, modstate, k, execute=True):
++ '''Raise keycmd & modcmd update events.'''
++
++ keycmd, modcmd = k.get_keycmd(), ''.join(modstate) + k.get_modcmd()
++
++ if k.is_modcmd:
++ self.logger.debug('modcmd_update, %s', modcmd)
++ self.uzbl.event('MODCMD_UPDATE', modstate, k)
++
++ else:
++ self.logger.debug('keycmd_update, %s', keycmd)
++ self.uzbl.event('KEYCMD_UPDATE', modstate, k)
++
++ config = Config[self.uzbl]
++ if config.get('modcmd_updates', '1') == '1':
++ new_modcmd = ''.join(modstate) + k.get_modcmd()
++ if not new_modcmd or not k.is_modcmd:
++ if 'modcmd' in config:
++ del config['modcmd']
++
++ elif new_modcmd == modcmd:
++ config['modcmd'] = MODCMD_FORMAT % uzbl_escape(modcmd)
++
++ if config.get('keycmd_events', '1') != '1':
++ return
++
++ new_keycmd = k.get_keycmd()
++ if not new_keycmd:
++ del config['keycmd']
++
++ elif new_keycmd == keycmd:
++ # Generate the pango markup for the cursor in the keycmd.
++ config['keycmd'] = str(k.markup())
++
++ def parse_key_event(self, key):
++ ''' Build a set from the modstate part of the event, and pass all keys through modmap '''
++
++ modstate, key = splitquoted(key)
++ modstate = set(['<%s>' % self.modmap_key(k) for k in modstate.split('|') if k])
++
++ key = self.modmap_key(key)
++ return modstate, key
++
++ def key_press(self, key):
++ '''Handle KEY_PRESS events. Things done by this function include:
++
++ 1. Ignore all shift key presses (shift can be detected by capital chars)
++ 2. In non-modcmd mode:
++ a. append char to keycmd
++ 3. If not in modcmd mode and a modkey was pressed set modcmd mode.
++ 4. Keycmd is updated and events raised if anything is changed.'''
++
++ k = self.keylet
++ config = Config[self.uzbl]
++ modstate, key = self.parse_key_event(key)
++ k.is_modcmd = any(not self.key_ignored(m) for m in modstate)
++
++ self.logger.debug('key press modstate=%s', modstate)
++ if key.lower() == 'space' and not k.is_modcmd and k.keycmd:
++ k.insert_keycmd(' ')
++
++ elif not k.is_modcmd and len(key) == 1:
++ if config.get('keycmd_events', '1') != '1':
++ # TODO, make a note on what's going on here
++ k.keycmd = ''
++ k.cursor = 0
++ del config['keycmd']
++ return
++
++ k.insert_keycmd(key)
++
++ elif len(key) == 1:
++ k.modcmd += key
++
++ else:
++ if not self.key_ignored('<%s>' % key):
++ modstate.add('<%s>' % key)
++ k.is_modcmd = True
++
++ self.update_event(modstate, k)
++
++ def key_release(self, key):
++ '''Respond to KEY_RELEASE event. Things done by this function include:
++
++ 1. If in a mod-command then raise a MODCMD_EXEC.
++ 2. Update the keycmd uzbl variable if anything changed.'''
++ k = self.keylet
++ modstate, key = self.parse_key_event(key)
++
++ if len(key) > 1:
++ if k.is_modcmd:
++ self.uzbl.event('MODCMD_EXEC', modstate, k)
++
++ self.clear_modcmd()
++
++ def set_keycmd(self, keycmd):
++ '''Allow setting of the keycmd externally.'''
++
++ self.keylet.set_keycmd(keycmd)
++ self.update_event(set(), self.keylet, False)
++
++ def inject_keycmd(self, keycmd):
++ '''Allow injecting of a string into the keycmd at the cursor position.'''
++
++ self.keylet.insert_keycmd(keycmd)
++ self.update_event(set(), self.keylet, False)
++
++ def append_keycmd(self, keycmd):
++ '''Allow appening of a string to the keycmd.'''
++
++ self.keylet.append_keycmd(keycmd)
++ self.update_event(set(), self.keylet, False)
++
++ def keycmd_strip_word(self, args):
++ ''' Removes the last word from the keycmd, similar to readline ^W '''
++
++ args = splitquoted(args)
++ assert len(args) <= 1
++ self.logger.debug('STRIPWORD %r %r', args, self.keylet)
++ if self.keylet.strip_word(*args):
++ self.update_event(set(), self.keylet, False)
++
++ def keycmd_backspace(self, *args):
++ '''Removes the character at the cursor position in the keycmd.'''
++
++ if self.keylet.backspace():
++ self.update_event(set(), self.keylet, False)
++
++ def keycmd_delete(self, *args):
++ '''Removes the character after the cursor position in the keycmd.'''
++
++ if self.keylet.delete():
++ self.update_event(set(), self.keylet, False)
++
++ def keycmd_exec_current(self, *args):
++ '''Raise a KEYCMD_EXEC with the current keylet and then clear the
++ keycmd.'''
++
++ self.uzbl.event('KEYCMD_EXEC', set(), self.keylet)
++ self.clear_keycmd()
++
++ def set_cursor_pos(self, args):
++ '''Allow setting of the cursor position externally. Supports negative
++ indexing and relative stepping with '+' and '-'.'''
++
++ args = splitquoted(args)
++ assert len(args) == 1
++
++ self.keylet.set_cursor_pos(args[0])
++ self.update_event(set(), self.keylet, False)
++
++# vi: set et ts=4:
++
+diff --git a/uzbl/plugins/mode.py b/uzbl/plugins/mode.py
+new file mode 100644
+index 0000000..6eaf009
+--- /dev/null
++++ b/uzbl/plugins/mode.py
+@@ -0,0 +1,69 @@
++from collections import defaultdict
++
++from .on_set import OnSetPlugin
++from .config import Config
++from uzbl.arguments import splitquoted, is_quoted
++from uzbl.ext import PerInstancePlugin
++
++
++class ModePlugin(PerInstancePlugin):
++ def __init__(self, uzbl):
++ super(ModePlugin, self).__init__(uzbl)
++ self.mode_config = defaultdict(dict)
++ uzbl.connect('MODE_CONFIG', self.parse_mode_config)
++ uzbl.connect('MODE_CONFIRM', self.confirm_change)
++ OnSetPlugin[uzbl].on_set('mode', self.mode_updated, False)
++ OnSetPlugin[uzbl].on_set('default_mode', self.default_mode_updated, False)
++
++ def cleanup(self):
++ self.mode_config.clear()
++
++ def parse_mode_config(self, args):
++ '''Parse `MODE_CONFIG <mode> <var> = <value>` event and update config
++ if the `<mode>` is the current mode.'''
++
++ args = splitquoted(args)
++ assert len(args) >= 3, 'missing mode config args %r' % args
++ mode = args[0]
++ key = args[1]
++ assert args[2] == '=', 'invalid mode config set syntax'
++
++ # Use the rest of the line verbatim as the value unless it's a
++ # single properly quoted string
++ if len(args) == 4 and is_quoted(args.raw(3)):
++ value = args[3]
++ else:
++ value = args.raw(3).strip()
++
++ self.logger.debug('value %r', value)
++
++ self.mode_config[mode][key] = value
++ config = Config[self.uzbl]
++ if config.get('mode', None) == mode:
++ config[key] = value
++
++ def default_mode_updated(self, var, mode):
++ config = Config[self.uzbl]
++ if mode and not config.get('mode', None):
++ self.logger.debug('setting mode to default %r' % mode)
++ config['mode'] = mode
++
++ def mode_updated(self, var, mode):
++ config = Config[self.uzbl]
++ if not mode:
++ mode = config.get('default_mode', 'command')
++ self.logger.debug('setting mode to default %r' % mode)
++ config['mode'] = mode
++ return
++
++ # Load mode config
++ mode_config = self.mode_config.get(mode, None)
++ if mode_config:
++ config.update(mode_config)
++
++ self.uzbl.send('event MODE_CONFIRM %s' % mode)
++
++ def confirm_change(self, mode):
++ config = Config[self.uzbl]
++ if mode and config.get('mode', None) == mode:
++ self.uzbl.event('MODE_CHANGED', mode)
+diff --git a/uzbl/plugins/on_event.py b/uzbl/plugins/on_event.py
+new file mode 100644
+index 0000000..cf33799
+--- /dev/null
++++ b/uzbl/plugins/on_event.py
+@@ -0,0 +1,106 @@
++'''Plugin provides arbitrary binding of uzbl events to uzbl commands.
++
++Formatting options:
++ %s = space separated string of the arguments
++ %r = escaped and quoted version of %s
++ %1 = argument 1
++ %2 = argument 2
++ %n = argument n
++
++Usage:
++ request ON_EVENT LINK_HOVER set selected_uri = $1
++ --> LINK_HOVER http://uzbl.org/
++ <-- set selected_uri = http://uzbl.org/
++
++ request ON_EVENT CONFIG_CHANGED print Config changed: %1 = %2
++ --> CONFIG_CHANGED selected_uri http://uzbl.org/
++ <-- print Config changed: selected_uri = http://uzbl.org/
++'''
++
++import re
++import fnmatch
++from functools import partial
++
++from uzbl.arguments import splitquoted
++from .cmd_expand import cmd_expand
++from uzbl.ext import PerInstancePlugin
++
++def match_args(pattern, args):
++ if len(pattern) > len(args):
++ return False
++ for p, a in zip(pattern, args):
++ if not fnmatch.fnmatch(a, p):
++ return False
++ return True
++
++
++class OnEventPlugin(PerInstancePlugin):
++
++ def __init__(self, uzbl):
++ '''Export functions and connect handlers to events.'''
++ super(OnEventPlugin, self).__init__(uzbl)
++
++ self.events = {}
++
++ uzbl.connect('ON_EVENT', self.parse_on_event)
++
++ def event_handler(self, *args, **kargs):
++ '''This function handles all the events being watched by various
++ on_event definitions and responds accordingly.'''
++
++ # Could be connected to a EM internal event that can use anything as args
++ if len(args) == 1 and isinstance(args[0], str):
++ args = splitquoted(args[0])
++
++ event = kargs['on_event']
++ if event not in self.events:
++ return
++
++ commands = self.events[event]
++ for cmd, pattern in list(commands.items()):
++ if not pattern or match_args(pattern, args):
++ cmd = cmd_expand(cmd, args)
++ self.uzbl.send(cmd)
++
++ def on_event(self, event, pattern, cmd):
++ '''Add a new event to watch and respond to.'''
++
++ event = event.upper()
++ self.logger.debug('new event handler %r %r %r', event, pattern, cmd)
++ if event not in self.events:
++ self.uzbl.connect(event,
++ partial(self.event_handler, on_event=event))
++ self.events[event] = {}
++
++ cmds = self.events[event]
++ if cmd not in cmds:
++ cmds[cmd] = pattern
++
++ def parse_on_event(self, args):
++ '''Parse ON_EVENT events and pass them to the on_event function.
++
++ Syntax: "event ON_EVENT <EVENT_NAME> commands".'''
++
++ args = splitquoted(args)
++ assert args, 'missing on event arguments'
++
++ # split arguments into event name, optional argument pattern and command
++ event = args[0]
++ pattern = []
++ if args[1] == '[':
++ for i, arg in enumerate(args[2:]):
++ if arg == ']':
++ break
++ pattern.append(arg)
++ command = args.raw(3+i)
++ else:
++ command = args.raw(1)
++
++ assert event and command, 'missing on event command'
++ self.on_event(event, pattern, command)
++
++ def cleanup(self):
++ self.events.clear()
++ super(OnEventPlugin, self).cleanup()
++
++# vi: set et ts=4:
+diff --git a/uzbl/plugins/on_set.py b/uzbl/plugins/on_set.py
+new file mode 100644
+index 0000000..f6b9229
+--- /dev/null
++++ b/uzbl/plugins/on_set.py
+@@ -0,0 +1,85 @@
++from re import compile
++from functools import partial
++
++import uzbl.plugins.config
++from .cmd_expand import cmd_expand
++from uzbl.arguments import splitquoted
++from uzbl.ext import PerInstancePlugin
++import collections
++
++valid_glob = compile('^[A-Za-z0-9_\*\.]+$').match
++
++def make_matcher(glob):
++ '''Make matcher function from simple glob.'''
++
++ pattern = "^%s$" % glob.replace('*', '[^\s]*')
++ return compile(pattern).match
++
++
++class OnSetPlugin(PerInstancePlugin):
++
++ def __init__(self, uzbl):
++ super(OnSetPlugin, self).__init__(uzbl)
++ self.on_sets = {}
++ uzbl.connect('ON_SET', self.parse_on_set)
++ uzbl.connect('CONFIG_CHANGED', self.check_for_handlers)
++
++ def _exec_handlers(self, handlers, key, arg):
++ '''Execute the on_set handlers that matched the key.'''
++
++ for handler in handlers:
++ if isinstance(handler, collections.Callable):
++ handler(key, arg)
++ else:
++ self.uzbl.send(cmd_expand(handler, [key, arg]))
++
++ def check_for_handlers(self, key, arg):
++ '''Check for handlers for the current key.'''
++
++ for (matcher, handlers) in list(self.on_sets.values()):
++ if matcher(key):
++ self._exec_handlers(handlers, key, arg)
++
++ def on_set(self, glob, handler, prepend=True):
++ '''Add a new handler for a config key change.
++
++ Structure of the `self.on_sets` dict:
++ { glob : ( glob matcher function, handlers list ), .. }
++ '''
++
++ assert valid_glob(glob)
++
++ while '**' in glob:
++ glob = glob.replace('**', '*')
++
++ if isinstance(handler, collections.Callable):
++ orig_handler = handler
++ if prepend:
++ handler = partial(handler, self.uzbl)
++
++ else:
++ orig_handler = handler = str(handler)
++
++ if glob in self.on_sets:
++ (matcher, handlers) = self.on_sets[glob]
++ handlers.append(handler)
++
++ else:
++ matcher = make_matcher(glob)
++ self.on_sets[glob] = (matcher, [handler,])
++
++ self.logger.info('on set %r call %r' % (glob, orig_handler))
++
++
++ def parse_on_set(self, args):
++ '''Parse `ON_SET <glob> <command>` event then pass arguments to the
++ `on_set(..)` function.'''
++
++ args = splitquoted(args)
++ assert len(args) >= 2
++ glob = args[0]
++ command = args.raw(1)
++
++ assert glob and command and valid_glob(glob)
++ self.on_set(glob, command)
++
+diff --git a/uzbl/plugins/progress_bar.py b/uzbl/plugins/progress_bar.py
+new file mode 100644
+index 0000000..5eb10d3
+--- /dev/null
++++ b/uzbl/plugins/progress_bar.py
+@@ -0,0 +1,92 @@
++import re
++from .config import Config
++
++from uzbl.ext import PerInstancePlugin
++
++class ProgressBar(PerInstancePlugin):
++ splitfrmt = re.compile(r'(%[A-Z][^%]|%[^%])').split
++
++ def __init__(self, uzbl):
++ super(ProgressBar, self).__init__(uzbl)
++ uzbl.connect('LOAD_COMMIT', lambda uri: self.update_progress())
++ uzbl.connect('LOAD_PROGRESS', self.update_progress)
++ self.updates = 0
++
++ def update_progress(self, progress=None):
++ '''Updates the progress.output variable on LOAD_PROGRESS update.
++
++ The current substitution options are:
++ %d = done char * done
++ %p = pending char * remaining
++ %c = percent done
++ %i = int done
++ %s = -\|/ spinner
++ %t = percent pending
++ %o = int pending
++ %r = sprites
++
++ Default configuration options:
++ progress.format = [%d>%p]%c
++ progress.width = 8
++ progress.done = =
++ progress.pending =
++ progress.spinner = -\|/
++ progress.sprites = loading
++ '''
++
++ if progress is None:
++ self.updates = 0
++ progress = 100
++
++ else:
++ self.updates += 1
++ progress = int(progress)
++
++ # Get progress config vars.
++ config = Config[self.uzbl]
++ frmt = config.get('progress.format', '[%d>%p]%c')
++ width = int(config.get('progress.width', 8))
++ done_symbol = config.get('progress.done', '=')
++ pend = config.get('progress.pending', None)
++ pending_symbol = pend if pend else ' '
++
++ # Get spinner character
++ spinner = config.get('progress.spinner', '-\\|/')
++ index = 0 if progress == 100 else self.updates % len(spinner)
++ spinner = '\\\\' if spinner[index] == '\\' else spinner[index]
++
++ # get sprite character
++ sprites = config.get('progress.sprites', 'loading')
++ index = int(((progress/100.0)*len(sprites))+0.5)-1
++ sprite = '%r' % ('\\\\' if sprites[index] == '\\' else sprites[index])
++
++ # Inflate the done and pending bars to stop the progress bar
++ # jumping around.
++ if '%c' in frmt or '%i' in frmt:
++ count = frmt.count('%c') + frmt.count('%i')
++ width += (3-len(str(progress))) * count
++
++ if '%t' in frmt or '%o' in frmt:
++ count = frmt.count('%t') + frmt.count('%o')
++ width += (3-len(str(100-progress))) * count
++
++ done = int(((progress/100.0)*width)+0.5)
++ pending = width - done
++
++ # values to replace with
++ values = {
++ 'd': done_symbol * done,
++ 'p': pending_symbol * pending,
++ 'c': '%d%%' % progress,
++ 'i': '%d' % progress,
++ 't': '%d%%' % (100 - progress),
++ 'o': '%d' % (100 - progress),
++ 's': spinner,
++ 'r': sprite
++ }
++
++ frmt = ''.join([str(values[k[1:]]) if k.startswith('%') else k for
++ k in self.splitfrmt(frmt)])
++
++ if config.get('progress.output', None) != frmt:
++ config['progress.output'] = frmt
+--- uzbl-2012.05.14/Makefile~ 2013-12-08 16:55:13.000000000 +0100
++++ uzbl-2012.05.14/Makefile 2013-12-08 16:56:12.412142265 +0100
+@@ -189,7 +189,7 @@
+ install -m755 uzbl-core $(INSTALLDIR)/bin/uzbl-core
+
+ install-event-manager: install-dirs
+- $(PYTHON) setup.py install --prefix=$(PREFIX) --install-scripts=$(INSTALLDIR)/bin $(PYINSTALL_EXTRA)
++ $(PYTHON) setup.py install --prefix=$(PREFIX) --root=$(DESTDIR) --install-scripts=$(PREFIX)/bin $(PYINSTALL_EXTRA)
+
+ install-uzbl-browser: install-dirs install-uzbl-core install-event-manager
+ sed 's#^PREFIX=.*#PREFIX=$(RUN_PREFIX)#' < bin/uzbl-browser > $(INSTALLDIR)/bin/uzbl-browser
projects / packages / uzbl.git / commitdiff