Merge lp:~kalikiana/midori/popup into lp:midori

[Cris Dywan]

Implement dialog windows opened via javascript

[Cris Dywan (kalikiana)]

Meh, the cmake stuff shows up there. Let's hold this off for a moment.

Unmerged revisions

=== added file 'CMakeLists.txt'
--- CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ CMakeLists.txt	2013-09-01 12:21:28 +0000
@@ -0,0 +1,166 @@
+# Copyright (C) 2013 Christian Dywan <[e-mail]>
+
+cmake_minimum_required(VERSION 2.6)
+cmake_policy(VERSION 2.6)
+project(midori C)
+add_definitions("-DPACKAGE_NAME=\"${CMAKE_PROJECT_NAME}\"")
+add_definitions("-DPACKAGE_BUGREPORT=\"https://bugs.launchpad.net/midori\"")
+
+set(VERSION 0.5.5)
+add_definitions("-DPACKAGE_VERSION=\"${VERSION}\"")
+add_definitions("-DMIDORI_VERSION_SUFFIX=\"${VERSION}\"")
+ 
+string(REPLACE "." ";" VERSION_LIST ${VERSION})
+LIST(GET VERSION_LIST 0 MIDORI_MAJOR_VERSION)
+add_definitions("-DMIDORI_MAJOR_VERSION=${MIDORI_MAJOR_VERSION}")
+LIST(GET VERSION_LIST 1 MIDORI_MINOR_VERSION)
+add_definitions("-DMIDORI_MINOR_VERSION=${MIDORI_MINOR_VERSION}")
+LIST(GET VERSION_LIST 2 MIDORI_MICRO_VERSION)
+add_definitions("-DMIDORI_MICRO_VERSION=${MIDORI_MICRO_VERSION}")
+
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
+# Disallow building during install to avoid permission problems
+set(CMAKE_SKIP_INSTALL_ALL_DEPENDENCY 1)
+
+include(GNUInstallDirs)
+set(DATADIR ${CMAKE_INSTALL_FULL_DATADIR})
+add_definitions("-DMDATADIR=\"${DATADIR}\"")
+add_definitions("-DSYSCONFDIR=\"${CMAKE_INSTALL_FULL_SYSCONFDIR}\"")
+add_definitions("-DLIBDIR=\"${CMAKE_INSTALL_FULL_LIBDIR}\"")
+add_definitions("-DDOCDIR=\"${CMAKE_INSTALL_FULL_DOCDIR}\"")
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/config.h" "/* # generated file (stub) */")
+
+find_package(PkgConfig)
+pkg_check_modules(DEPS REQUIRED
+                  libxml-2.0>=2.6
+                  sqlite3>=3.6.19
+                  gmodule-2.0
+                  gio-2.0>=2.32.3
+                  libsoup-gnome-2.4>=2.27.90
+                  )
+add_definitions("-DHAVE_LIBXML")
+add_definitions("-DGIO_VERSION=\"${DEPS_gio-2.0_VERSION}\"")
+add_definitions("-DLIBSOUP_VERSION=\"${DEPS_libsoup-gnome-2.4_VERSION}\"")
+set(PKGS posix linux libxml-2.0 sqlite3 gmodule-2.0 gio-2.0 libsoup-2.4)
+if (${DEPS_libsoup-gnome-2.4_VERSION} VERSION_GREATER "2.34.0")
+    set(VALAFLAGS ${VALAFLAGS} "-D;HAVE_LIBSOUP_2_34_0")
+endif ()
+
+pkg_check_modules(OPTS libnotify)
+add_definitions("-DLIBNOTIFY_VERSION=\"${OPTS_libnotify_VERSION}\"")
+set(PKGS ${PKGS} libnotify)
+
+option(USE_GTK3 "Use GTK+3" OFF)
+option(HALF_BRO_INCOM_WEBKIT2 "Serve as a guniea pig" OFF)
+option(USE_ZEITGEIST "Zeitgeist history integration" ON)
+option(USE_GRANITE "Fancy notebook and pop-overs" OFF)
+
+if (USE_GRANITE)
+    if (NOT USE_GTK3 AND NOT HALF_BRO_INCOM_WEBKIT2)
+        set(USE_GTK3 ON)
+    endif ()
+
+    pkg_check_modules(GRANITE granite>=0.2)
+    set(OPTS_INCLUDE_DIRS "${OPTS_INCLUDE_DIRS};${GRANITE_INCLUDE_DIRS}")
+    set(OPTS_LIBRARIES "${OPTS_LIBRARIES};${GRANITE_LIBRARIES}")
+    add_definitions("-DHAVE_GRANITE")
+    add_definitions("-DGRANITE_VERSION=\"${GRANITE_VERSION}\"")
+    set(PKGS ${PKGS} granite)
+else ()
+    add_definitions("-DGRANITE_VERSION=\"No\"")
+endif()
+
+if (USE_ZEITGEIST)
+    pkg_check_modules(ZEITGEIST zeitgeist-1.0>=0.3.14)
+    set(OPTS_INCLUDE_DIRS "${OPTS_INCLUDE_DIRS};${ZEITGEIST_INCLUDE_DIRS}")
+    set(OPTS_LIBRARIES "${OPTS_LIBRARIES};${ZEITGEIST_LIBRARIES}")
+    add_definitions("-DHAVE_ZEITGEIST")
+    set(PKGS ${PKGS} zeitgeist-1.0)
+endif()
+
+if (USE_GTK3)
+    pkg_check_modules(DEPS_GTK REQUIRED
+                      gtk+-3.0>=3.0.0
+                      webkitgtk-3.0>=1.8.3
+                      javascriptcoregtk-3.0
+                      )
+    add_definitions("-DGTK_VERSION=\"${DEPS_GTK_gtk+-3.0_VERSION}\"")
+    add_definitions("-DWEBKIT_VERSION=\"${DEPS_GTK_webkitgtk-3.0_VERSION}\"")
+    set(PKGS ${PKGS} gtk+-3.0)
+    set(EXTRA_VAPIS ${EXTRA_VAPIS} "${CMAKE_SOURCE_DIR}/midori/webkitgtk-3.0.vapi")
+    pkg_check_modules(OPTS_GTK
+                      gcr-3>=2.32
+                      unique-3.0>=0.9
+                      )
+    if (OPTS_GTK_unique-3.0_VERSION)
+        add_definitions("-DHAVE_UNIQUE")
+        add_definitions("-DUNIQUE_VERSION=\"${OPTS_GTK_unique-3.0_VERSION}\"")
+    endif ()
+    add_definitions("-DGCR_VERSION=\"${OPTS_GTK_gcr-3_VERSION}\"")
+    set(VALAFLAGS ${VALAFLAGS} "-D;HAVE_GTK3")
+elseif (HALF_BRO_INCOM_WEBKIT2)
+    # Note: WebKitGTK+ 2.0.0 matches 1.11.91; 1.11.92 > 2.0.0
+    pkg_check_modules(DEPS_GTK REQUIRED
+                      gtk+-3.0>=3.0.0
+                      webkit2gtk-3.0>=1.11.91
+                      javascriptcoregtk-3.0
+                      )
+                  add_definitions("-DHAVE_WEBKIT2")
+    add_definitions("-DGTK_VERSION=\"${DEPS_GTK_gtk+-3.0_VERSION}\"")
+    add_definitions("-DWEBKIT_VERSION=\"${DEPS_GTK_webkit2gtk-3.0_VERSION}\"")
+    set(PKGS ${PKGS} gtk+-3.0)
+    set(EXTRA_VAPIS ${EXTRA_VAPIS} "${CMAKE_SOURCE_DIR}/midori/webkit2gtk-3.0.vapi")
+    pkg_check_modules(OPTS_GTK
+                      gcr-3>=2.32
+                      unique-3.0>=0.9
+                      )
+    if (OPTS_GTK_unique-3.0_VERSION)
+        add_definitions("-DHAVE_UNIQUE")
+        add_definitions("-DUNIQUE_VERSION=\"${OPTS_GTK_unique-3.0_VERSION}\"")
+    endif ()
+    add_definitions("-DGCR_VERSION=\"${OPTS_GTK_gcr-3_VERSION}\"")
+    set(VALAFLAGS ${VALAFLAGS} "-D;HAVE_GTK3")
+    set(VALAFLAGS ${VALAFLAGS} "-D;HAVE_WEBKIT2")
+else ()
+    pkg_check_modules(DEPS_GTK REQUIRED
+                      gtk+-2.0>=2.24.0
+                      webkit-1.0>=1.8.3
+                      javascriptcoregtk-1.0
+                      )
+    add_definitions("-DGTK_VERSION=\"${DEPS_GTK_gtk+-2.0_VERSION}\"")
+    add_definitions("-DWEBKIT_VERSION=\"${DEPS_GTK_webkit-1.0_VERSION}\"")
+    set(PKGS ${PKGS} gtk+-2.0)
+    set(EXTRA_VAPIS ${EXTRA_VAPIS} "${CMAKE_SOURCE_DIR}/midori/webkitgtk-3.0.vapi")
+    # Always pass >1 module, otherwise we get different variable names
+    pkg_check_modules(OPTS_GTK
+                      gtk+-2.0>=2.24.0
+                      unique-1.0>=0.9
+                      )
+    if (OPTS_GTK_unique-1.0_VERSION)
+        add_definitions("-DHAVE_UNIQUE")
+        add_definitions("-DUNIQUE_VERSION=\"${OPTS_GTK_unique-1.0_VERSION}\"")
+    endif ()
+    add_definitions("-DGCR_VERSION=\"No\"")
+endif ()
+
+find_package(Vala REQUIRED)
+vala_require("0.16.0")
+set(VALAFLAGS ${VALAFLAGS}
+    --enable-deprecated
+    --debug
+    )
+
+# dh_translations detects this if there's no variable used
+set (GETTEXT_PACKAGE "midori")
+add_definitions("-DGETTEXT_PACKAGE=\"${GETTEXT_PACKAGE}\"")
+
+set(CFLAGS "-w -Wno-deprecated-declarations")
+set(LIBMIDORI "${CMAKE_PROJECT_NAME}-core")
+
+add_subdirectory (midori)
+add_subdirectory (po)
+add_subdirectory (icons)
+add_subdirectory (data)
+enable_testing()
+add_subdirectory (tests)
+add_subdirectory (extensions)

=== added directory 'cmake'
=== added file 'cmake/ContainTest.cmake'
--- cmake/ContainTest.cmake	1970-01-01 00:00:00 +0000
+++ cmake/ContainTest.cmake	2013-09-01 12:21:28 +0000
@@ -0,0 +1,18 @@
+# Copyright (C) 2013 Christian Dywan <[e-mail]>
+
+include(ParseArguments)
+
+macro(contain_test test_name)
+    parse_arguments(ARGS "TEST" "" ${ARGN})
+    set(TEST_ENV "")
+    foreach(VARIABLE XDG_DATA_HOME XDG_CONFIG_HOME XDG_CACHE_HOME XDG_DATA_HOME XDG_RUNTIME_DIR TMPDIR)
+        set(CONTAINER "${CMAKE_CURRENT_BINARY_DIR}/${test_name}-folders/${VARIABLE}")
+        file(MAKE_DIRECTORY ${CONTAINER})
+        set(TEST_ENV "${TEST_ENV}${VARIABLE}=${CONTAINER};")
+    endforeach()
+    set_tests_properties(${test_name} PROPERTIES
+                         WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+                         TIMEOUT 42
+                         ENVIRONMENT "${TEST_ENV}"
+                         )
+endmacro(contain_test)

=== added file 'cmake/FindIntltool.cmake'
--- cmake/FindIntltool.cmake	1970-01-01 00:00:00 +0000
+++ cmake/FindIntltool.cmake	2013-09-01 12:21:28 +0000
@@ -0,0 +1,30 @@
+# FindIntltool.cmake
+#
+# Jim Nelson <[e-mail]>
+# Copyright 2012-2013 Yorba Foundation
+# Copyright (C) 2013 Christian Dywan
+
+find_program (INTLTOOL_MERGE_EXECUTABLE intltool-merge)
+find_program (INTLTOOL_UPDATE_EXECUTABLE intltool-update)
+
+if (INTLTOOL_MERGE_EXECUTABLE)
+    set (INTLTOOL_MERGE_FOUND TRUE)
+    macro (INTLTOOL_MERGE_DESKTOP desktop_id po_dir)
+        add_custom_target ("${desktop_id}.desktop" ALL
+            ${INTLTOOL_MERGE_EXECUTABLE} --desktop-style ${CMAKE_SOURCE_DIR}/${po_dir}
+                ${CMAKE_CURRENT_SOURCE_DIR}/${desktop_id}.desktop.in ${desktop_id}.desktop
+        )
+        install (FILES "${CMAKE_CURRENT_BINARY_DIR}/${desktop_id}.desktop"
+                 DESTINATION "${CMAKE_INSTALL_PREFIX}/share/applications")
+    endmacro (INTLTOOL_MERGE_DESKTOP desktop_id po_dir)
+endif ()
+
+if (INTLTOOL_UPDATE_EXECUTABLE)
+    set (INTLTOOL_UPDATE_FOUND TRUE)
+    add_custom_target (pot
+        COMMAND ${INTLTOOL_UPDATE_EXECUTABLE} "-p" "-g" ${GETTEXT_PACKAGE}
+        WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/po"
+        )
+endif ()
+
+

=== added file 'cmake/FindVala.cmake'
--- cmake/FindVala.cmake	1970-01-01 00:00:00 +0000
+++ cmake/FindVala.cmake	2013-09-01 12:21:28 +0000
@@ -0,0 +1,18 @@
+# Copyright (C) 2013 Christian Dywan <[e-mail]>
+
+find_program(VALA_EXECUTABLE NAMES valac)
+if (NOT VALA_NOTFOUND)
+    execute_process(COMMAND ${VALA_EXECUTABLE} "--version" OUTPUT_VARIABLE "VALA_VERSION")
+    string(REPLACE "Vala " "" VALA_VERSION ${VALA_VERSION})
+    string(STRIP ${VALA_VERSION} VALA_VERSION)
+else ()
+    message(FATAL_ERROR "valac not found")
+endif ()
+
+macro(vala_require VALA_REQUIRED)
+    if (${VALA_VERSION} VERSION_GREATER ${VALA_REQUIRED} OR ${VALA_VERSION} VERSION_EQUAL ${VALA_REQUIRED})
+        message(STATUS "valac ${VALA_VERSION} found")
+    else ()
+        message(FATAL_ERROR "valac >= ${VALA_REQUIRED} or later required")
+    endif ()
+endmacro(vala_require)

=== added file 'cmake/GLibHelpers.cmake'
--- cmake/GLibHelpers.cmake	1970-01-01 00:00:00 +0000
+++ cmake/GLibHelpers.cmake	2013-09-01 12:21:28 +0000
@@ -0,0 +1,71 @@
+# Copyright (C) 2010 David Sansome <[e-mail]>
+cmake_minimum_required(VERSION 2.6)
+if(POLICY CMP0011)
+  cmake_policy(SET CMP0011 NEW)
+endif(POLICY CMP0011)
+
+find_program(GLIB_MKENUMS glib-mkenums)
+find_program(GLIB_GENMARSHAL glib-genmarshal)
+
+macro(add_glib_marshal outfiles name prefix otherinclude)
+  add_custom_command(
+    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.h"
+    COMMAND ${GLIB_GENMARSHAL} --header "--prefix=${prefix}"
+            "${CMAKE_CURRENT_SOURCE_DIR}/${name}.list"
+            > "${CMAKE_CURRENT_BINARY_DIR}/${name}.h"
+    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${name}.list"
+  )
+  add_custom_command(
+    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.c"
+    COMMAND echo "\\#include \\\"${otherinclude}\\\"" > "${CMAKE_CURRENT_BINARY_DIR}/${name}.c"
+    COMMAND echo "\\#include \\\"glib-object.h\\\"" >> "${CMAKE_CURRENT_BINARY_DIR}/${name}.c"
+    COMMAND echo "\\#include \\\"${name}.h\\\"" >> "${CMAKE_CURRENT_BINARY_DIR}/${name}.c"
+    COMMAND ${GLIB_GENMARSHAL} --body "--prefix=${prefix}"
+            "${CMAKE_CURRENT_SOURCE_DIR}/${name}.list"
+            >> "${CMAKE_CURRENT_BINARY_DIR}/${name}.c"
+    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${name}.list"
+            "${CMAKE_CURRENT_BINARY_DIR}/${name}.h"
+  )
+  list(APPEND ${outfiles} "${CMAKE_CURRENT_BINARY_DIR}/${name}.c")
+endmacro(add_glib_marshal)
+
+macro(add_glib_enumtypes_t outfiles name htemplate ctemplate)
+  add_custom_command(
+    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.h"
+    COMMAND ${GLIB_MKENUMS}
+            --template "${htemplate}"
+            ${ARGN} > "${CMAKE_CURRENT_BINARY_DIR}/${name}.h"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    DEPENDS ${ARGN} "${htemplate}"
+  )
+  add_custom_command(
+    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.c"
+    COMMAND ${GLIB_MKENUMS}
+            --template "${ctemplate}"
+            ${ARGN} > "${CMAKE_CURRENT_BINARY_DIR}/${name}.c"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    DEPENDS ${ARGN} ${ctemplate}
+            "${CMAKE_CURRENT_BINARY_DIR}/${name}.h"
+  )
+  list(APPEND ${outfiles} "${CMAKE_CURRENT_BINARY_DIR}/${name}.c")
+endmacro(add_glib_enumtypes_t)
+
+macro(add_glib_enumtypes outfiles name includeguard)
+  set(htemplate "${CMAKE_CURRENT_BINARY_DIR}/${name}.h.template")
+  set(ctemplate "${CMAKE_CURRENT_BINARY_DIR}/${name}.c.template")
+
+  # Write the .h template
+  add_custom_command(
+    OUTPUT ${htemplate} ${ctemplate}
+    COMMAND ${CMAKE_COMMAND}
+        "-Dctemplate=${ctemplate}"
+        "-Dhtemplate=${htemplate}"
+        "-Dname=${name}"
+        "-Dincludeguard=${includeguard}"
+        "\"-Dheaders=${ARGN}\""
+        -P "${CMAKE_SOURCE_DIR}/CMake/MakeGLibEnumTemplates.cmake"
+    DEPENDS "${CMAKE_SOURCE_DIR}/CMake/MakeGLibEnumTemplates.cmake" ${headers}
+  )
+
+  add_glib_enumtypes_t(${outfiles} ${name} ${htemplate} ${ctemplate} ${ARGN})
+endmacro(add_glib_enumtypes)

=== added file 'cmake/ParseArguments.cmake'
--- cmake/ParseArguments.cmake	1970-01-01 00:00:00 +0000
+++ cmake/ParseArguments.cmake	2013-09-01 12:21:28 +0000
@@ -0,0 +1,36 @@
+##
+# This is a helper Macro to parse optional arguments in Macros/Functions
+# It has been taken from the public CMake wiki.  
+# See http://www.cmake.org/Wiki/CMakeMacroParseArguments for documentation and
+# licensing.
+##
+macro(parse_arguments prefix arg_names option_names)
+  set(DEFAULT_ARGS)
+  foreach(arg_name ${arg_names})
+    set(${prefix}_${arg_name})
+  endforeach(arg_name)
+  foreach(option ${option_names})
+    set(${prefix}_${option} FALSE)
+  endforeach(option)
+
+  set(current_arg_name DEFAULT_ARGS)
+  set(current_arg_list)
+  foreach(arg ${ARGN})
+    set(larg_names ${arg_names})
+    list(FIND larg_names "${arg}" is_arg_name)
+    if(is_arg_name GREATER -1)
+      set(${prefix}_${current_arg_name} ${current_arg_list})
+      set(current_arg_name ${arg})
+      set(current_arg_list)
+    else(is_arg_name GREATER -1)
+      set(loption_names ${option_names})
+      list(FIND loption_names "${arg}" is_option)
+      if(is_option GREATER -1)
+	    set(${prefix}_${arg} TRUE)
+      else(is_option GREATER -1)
+	    set(current_arg_list ${current_arg_list} ${arg})
+      endif(is_option GREATER -1)
+    endif(is_arg_name GREATER -1)
+  endforeach(arg)
+  set(${prefix}_${current_arg_name} ${current_arg_list})
+endmacro(parse_arguments)

=== added file 'cmake/ValaPrecompile.cmake'
--- cmake/ValaPrecompile.cmake	1970-01-01 00:00:00 +0000
+++ cmake/ValaPrecompile.cmake	2013-09-01 12:21:28 +0000
@@ -0,0 +1,236 @@
+##
+# Copyright 2009-2010 Jakob Westhoff. All rights reserved.
+# Copyright 2012 elementary.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#    1. Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+# 
+#    2. Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+# 
+# THIS SOFTWARE IS PROVIDED BY JAKOB WESTHOFF ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+# EVENT SHALL JAKOB WESTHOFF OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# 
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of Jakob Westhoff
+##
+
+include(ParseArguments)
+find_package(Vala REQUIRED)
+
+##
+# Compile vala files to their c equivalents for further processing. 
+#
+# The "vala_precompile" macro takes care of calling the valac executable on the
+# given source to produce c files which can then be processed further using
+# default cmake functions.
+# 
+# The first parameter provided is a variable, which will be filled with a list
+# of c files outputted by the vala compiler. This list can than be used in
+# conjuction with functions like "add_executable" or others to create the
+# neccessary compile rules with CMake.
+# 
+# The initial variable is followed by a list of .vala files to be compiled.
+# Please take care to add every vala file belonging to the currently compiled
+# project or library as Vala will otherwise not be able to resolve all
+# dependencies.
+# 
+# The following sections may be specified afterwards to provide certain options
+# to the vala compiler:
+# 
+# PACKAGES
+#   A list of vala packages/libraries to be used during the compile cycle. The
+#   package names are exactly the same, as they would be passed to the valac
+#   "--pkg=" option.
+# 
+# OPTIONS
+#   A list of optional options to be passed to the valac executable. This can be
+#   used to pass "--thread" for example to enable multi-threading support.
+#
+# CUSTOM_VAPIS
+#   A list of custom vapi files to be included for compilation. This can be
+#   useful to include freshly created vala libraries without having to install
+#   them in the system.
+#
+# GENERATE_VAPI
+#   Pass all the needed flags to the compiler to create an internal vapi for
+#   the compiled library. The provided name will be used for this and a
+#   <provided_name>.vapi file will be created.
+# 
+# GENERATE_HEADER
+#   Let the compiler generate a header file for the compiled code. There will
+#   be a header file as well as an internal header file being generated called
+#   <provided_name>.h and <provided_name>_internal.h
+#
+# GENERATE_GIR
+#   Have the compiler generate a GObject-Introspection repository file with
+#   name: <provided_name>.gir. This can be later used to create a binary typelib
+#   using the GI compiler.
+#
+# GENERATE_SYMBOLS
+#   Output a <provided_name>.symbols file containing all the exported symbols.
+# 
+# The following call is a simple example to the vala_precompile macro showing
+# an example to every of the optional sections:
+#
+#   vala_precompile(VALA_C mytargetname
+#       source1.vala
+#       source2.vala
+#       source3.vala
+#   PACKAGES
+#       gtk+-2.0
+#       gio-1.0
+#       posix
+#   DIRECTORY
+#       gen
+#   OPTIONS
+#       --thread
+#   CUSTOM_VAPIS
+#       some_vapi.vapi
+#   GENERATE_VAPI
+#       myvapi
+#   GENERATE_HEADER
+#       myheader
+#   GENERATE_GIR
+#       mygir
+#   GENERATE_SYMBOLS
+#       mysymbols
+#   )
+#
+# Most important is the variable VALA_C which will contain all the generated c
+# file names after the call.
+##
+
+macro(vala_precompile output target_name)
+    parse_arguments(ARGS "TARGET;PACKAGES;OPTIONS;DIRECTORY;GENERATE_GIR;GENERATE_SYMBOLS;GENERATE_HEADER;GENERATE_VAPI;CUSTOM_VAPIS" "" ${ARGN})
+
+    if(ARGS_DIRECTORY)
+        set(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${ARGS_DIRECTORY})
+    else(ARGS_DIRECTORY)
+        set(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    endif(ARGS_DIRECTORY)
+    include_directories(${DIRECTORY})
+    set(vala_pkg_opts "")
+    foreach(pkg ${ARGS_PACKAGES})
+        list(APPEND vala_pkg_opts "--pkg=${pkg}")
+    endforeach(pkg ${ARGS_PACKAGES})
+    set(in_files "")
+    set(out_files "")
+    set(out_files_display "")
+    set(${output} "")
+
+    foreach(src ${ARGS_DEFAULT_ARGS})
+        string(REGEX MATCH "^/" IS_MATCHED ${src})
+        if(${IS_MATCHED} MATCHES "/")
+            set(src_file_path ${src})
+        else()
+            set(src_file_path ${CMAKE_CURRENT_SOURCE_DIR}/${src})
+        endif()
+        list(APPEND in_files ${src_file_path})
+        string(REPLACE ".vala" ".c" src ${src})
+        string(REPLACE ".gs" ".c" src ${src})
+        if(${IS_MATCHED} MATCHES "/")
+            get_filename_component(VALA_FILE_NAME ${src} NAME)
+            set(out_file "${CMAKE_CURRENT_BINARY_DIR}/${VALA_FILE_NAME}")
+            list(APPEND out_files "${CMAKE_CURRENT_BINARY_DIR}/${VALA_FILE_NAME}")
+        else()
+            set(out_file "${DIRECTORY}/${src}")
+            list(APPEND out_files "${DIRECTORY}/${src}")
+        endif()
+        list(APPEND ${output} ${out_file})
+        list(APPEND out_files_display "${src}")
+    endforeach(src ${ARGS_DEFAULT_ARGS})
+
+    set(custom_vapi_arguments "")
+    if(ARGS_CUSTOM_VAPIS)
+        foreach(vapi ${ARGS_CUSTOM_VAPIS})
+            if(${vapi} MATCHES ${CMAKE_SOURCE_DIR} OR ${vapi} MATCHES ${CMAKE_BINARY_DIR})
+                list(APPEND custom_vapi_arguments ${vapi})
+            else (${vapi} MATCHES ${CMAKE_SOURCE_DIR} OR ${vapi} MATCHES ${CMAKE_BINARY_DIR})
+                list(APPEND custom_vapi_arguments ${CMAKE_CURRENT_SOURCE_DIR}/${vapi})
+            endif(${vapi} MATCHES ${CMAKE_SOURCE_DIR} OR ${vapi} MATCHES ${CMAKE_BINARY_DIR})
+        endforeach(vapi ${ARGS_CUSTOM_VAPIS})
+    endif(ARGS_CUSTOM_VAPIS)
+
+    set(vapi_arguments "")
+    if(ARGS_GENERATE_VAPI)
+        list(APPEND out_files "${DIRECTORY}/${ARGS_GENERATE_VAPI}.vapi")
+        list(APPEND out_files_display "${ARGS_GENERATE_VAPI}.vapi")
+        set(vapi_arguments "--library=${ARGS_GENERATE_VAPI}" "--vapi=${ARGS_GENERATE_VAPI}.vapi")
+
+        # Header and internal header is needed to generate internal vapi
+        if (NOT ARGS_GENERATE_HEADER)
+            set(ARGS_GENERATE_HEADER ${ARGS_GENERATE_VAPI})
+        endif(NOT ARGS_GENERATE_HEADER)
+    endif(ARGS_GENERATE_VAPI)
+
+    set(header_arguments "")
+    if(ARGS_GENERATE_HEADER)
+        list(APPEND out_files "${DIRECTORY}/${ARGS_GENERATE_HEADER}.h")
+        list(APPEND out_files_display "${ARGS_GENERATE_HEADER}.h")
+        list(APPEND header_arguments "--header=${ARGS_GENERATE_HEADER}.h")
+    endif(ARGS_GENERATE_HEADER)
+
+    set(gir_arguments "")
+    if(ARGS_GENERATE_GIR)
+        list(APPEND out_files "${DIRECTORY}/${ARGS_GENERATE_GIR}.gir")
+        list(APPEND out_files_display "${ARGS_GENERATE_GIR}.gir")
+        set(gir_arguments "--gir=${ARGS_GENERATE_GIR}.gir")
+    endif(ARGS_GENERATE_GIR)
+
+    set(symbols_arguments "")
+    if(ARGS_GENERATE_SYMBOLS)
+        list(APPEND out_files "${DIRECTORY}/${ARGS_GENERATE_SYMBOLS}.symbols")
+        list(APPEND out_files_display "${ARGS_GENERATE_SYMBOLS}.symbols")
+        set(symbols_arguments "--symbols=${ARGS_GENERATE_SYMBOLS}.symbols")
+    endif(ARGS_GENERATE_SYMBOLS)
+
+    # Workaround for a bug that would make valac run twice. This file is written
+    # after the vala compiler generates C source code.
+    set(OUTPUT_STAMP ${CMAKE_CURRENT_BINARY_DIR}/${target_name}_valac.stamp)
+
+    add_custom_command(
+    OUTPUT
+        ${OUTPUT_STAMP}
+    COMMAND 
+        ${VALA_EXECUTABLE} 
+    ARGS 
+        "-C" 
+        ${header_arguments} 
+        ${vapi_arguments} 
+        ${gir_arguments} 
+        ${symbols_arguments} 
+        "-b" ${CMAKE_CURRENT_SOURCE_DIR} 
+        "-d" ${DIRECTORY} 
+        ${vala_pkg_opts} 
+        ${ARGS_OPTIONS} 
+        ${in_files} 
+        ${custom_vapi_arguments}
+    COMMAND
+        touch
+    ARGS
+        ${OUTPUT_STAMP}
+    DEPENDS 
+        ${in_files} 
+        ${ARGS_CUSTOM_VAPIS}
+    COMMENT
+        "Generating ${out_files_display}"
+    )
+
+    # This command will be run twice for some reason (pass a non-empty string to COMMENT
+    # in order to see it). Since valac is not executed from here, this won't be a problem.
+    add_custom_command(OUTPUT ${out_files} DEPENDS ${OUTPUT_STAMP} COMMENT "")
+endmacro(vala_precompile)

=== added file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ data/CMakeLists.txt	2013-09-01 12:21:28 +0000
@@ -0,0 +1,34 @@
+# Copyright (C) 2013 Christian Dywan <[e-mail]>
+
+include(FindIntltool)
+if (NOT INTLTOOL_MERGE_FOUND)
+    message(FATAL_ERROR "intltool-merge not found")
+elseif (NOT INTLTOOL_UPDATE_FOUND)
+    message(FATAL_ERROR "intltool-update not found")
+endif ()
+
+file(GLOB_RECURSE DATA_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *)
+list(REMOVE_ITEM DATA_FILES "CMakeLists.txt")
+
+foreach(FILE ${DATA_FILES})
+    string(FIND ${FILE} "faq." FAQ_FILE)
+    string(FIND ${FILE} "midori." MIDORI_FILE)
+    string(FIND ${FILE} ".desktop" DESKTOP_FILE)
+    if (FAQ_FILE GREATER -1)
+    elseif (DESKTOP_FILE GREATER -1)
+        string(SUBSTRING ${FILE} 0 ${DESKTOP_FILE} DESKTOP_ID)
+        INTLTOOL_MERGE_DESKTOP (${DESKTOP_ID} po)
+    elseif(MIDORI_FILE GREATER -1)
+    else()
+        string(FIND ${FILE} "/" IS_DIR)
+        if (IS_DIR GREATER -1)
+            string(REPLACE "/" ";" DIR_LIST ${FILE})
+            LIST(GET DIR_LIST 0 S_DIR)
+            LIST(GET DIR_LIST 1 S_FILE)
+            install(FILES ${S_DIR}/${S_FILE} DESTINATION ${CMAKE_INSTALL_DATADIR}/midori/res/${S_DIR})
+        else ()
+            install(FILES ${FILE} DESTINATION ${CMAKE_INSTALL_DATADIR}/midori/res/)
+        endif()
+    endif()
+
+endforeach()

=== added file 'extensions/CMakeLists.txt'
--- extensions/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ extensions/CMakeLists.txt	2013-09-01 12:21:28 +0000
@@ -0,0 +1,92 @@
+# Copyright (C) 2013 Christian Dywan <[e-mail]>
+
+set(EXTENSIONDIR "${CMAKE_INSTALL_FULL_LIBDIR}/${CMAKE_PROJECT_NAME}")
+include_directories(
+                    "${CMAKE_SOURCE_DIR}"
+                    "${CMAKE_SOURCE_DIR}/midori"
+                    "${CMAKE_SOURCE_DIR}/katze"
+                    ${DEPS_INCLUDE_DIRS}
+                    ${OPTS_INCLUDE_DIRS}
+                    ${DEPS_GTK_INCLUDE_DIRS}
+                    ${OPTS_GTK_INCLUDE_DIRS}
+                    ${CMAKE_BINARY_DIR}
+                    "${CMAKE_BINARY_DIR}/midori"
+                    )
+file(GLOB EXTENSIONS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *)
+if (HALF_BRO_INCOM_WEBKIT2)
+    list(REMOVE_ITEM EXTENSIONS
+         "adblock.c"
+         "cookie-permissions"
+         "addons.c"
+         "formhistory"
+         "external-download-manager.vala"
+         "nojs"
+         "nsplugin-manager.vala"
+         )
+endif ()
+
+foreach(UNIT_SRC ${EXTENSIONS})
+    string(FIND ${UNIT_SRC} ".c" UNIT_EXTENSION)
+    if (UNIT_EXTENSION GREATER -1)
+        string(REPLACE ".c" "" UNIT ${UNIT_SRC})
+        add_library(${UNIT} MODULE ${UNIT_SRC})
+        target_link_libraries(${UNIT}
+                              ${LIBMIDORI}
+                              )
+        set_target_properties(${UNIT} PROPERTIES
+                              COMPILE_FLAGS ${CFLAGS}
+                              )
+        install(TARGETS ${UNIT}
+            LIBRARY DESTINATION ${EXTENSIONDIR}
+                )
+    endif ()
+endforeach ()
+
+foreach(UNIT_SRC ${EXTENSIONS})
+    string(FIND ${UNIT_SRC} "." UNIT_EXTENSION)
+    if (UNIT_EXTENSION EQUAL -1)
+        file(GLOB UNIT_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "${UNIT_SRC}/*.c")
+        if (UNIT_FILES)
+            add_library(${UNIT_SRC} MODULE ${UNIT_FILES})
+            target_link_libraries(${UNIT_SRC}
+                                  ${LIBMIDORI}
+                                  )
+            set_target_properties(${UNIT_SRC} PROPERTIES
+                                  COMPILE_FLAGS ${CFLAGS}
+                                  )
+            install(TARGETS ${UNIT_SRC}
+                    LIBRARY DESTINATION ${EXTENSIONDIR}
+                    )
+        endif ()
+    endif ()
+endforeach ()
+
+foreach(UNIT_SRC ${EXTENSIONS})
+    string(FIND ${UNIT_SRC} ".vala" UNIT_EXTENSION)
+    if (UNIT_EXTENSION GREATER -1)
+        string(REPLACE ".vala" "" UNIT ${UNIT_SRC})
+        include(ValaPrecompile)
+        vala_precompile(UNIT_SRC_C ${UNIT}
+            ${UNIT_SRC}
+        PACKAGES
+            ${PKGS}
+        OPTIONS
+            ${VALAFLAGS}
+        CUSTOM_VAPIS
+            ${EXTRA_VAPIS}
+            "${CMAKE_SOURCE_DIR}/midori/midori.vapi"
+            "${CMAKE_SOURCE_DIR}/katze/katze.vapi"
+            "${CMAKE_BINARY_DIR}/midori/${LIBMIDORI}.vapi"
+        )
+        add_library(${UNIT} MODULE ${UNIT_SRC_C})
+        target_link_libraries(${UNIT}
+                              ${LIBMIDORI}
+                              )
+        set_target_properties(${UNIT} PROPERTIES
+                              COMPILE_FLAGS ${CFLAGS}
+                              )
+        install(TARGETS ${UNIT}
+                LIBRARY DESTINATION ${EXTENSIONDIR}
+                )
+    endif ()
+endforeach ()

=== added file 'icons/CMakeLists.txt'
--- icons/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ icons/CMakeLists.txt	2013-09-01 12:21:28 +0000
@@ -0,0 +1,12 @@
+# Copyright (C) 2013 Christian Dywan <[e-mail]>
+
+macro(install_icon name cat size)
+    file(GLOB FILENAME RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "${size}/${name}.*")
+    install(FILES ${FILENAME} DESTINATION ${CMAKE_INSTALL_DATADIR}/icons/hicolor/${size}/${cat})
+endmacro()
+
+foreach(SIZE "16x16;22x22;scalable")
+    install_icon(midori apps ${SIZE})
+    install_icon(extension categories ${SIZE})
+    install_icon(internet-news-reader status ${SIZE})
+endforeach()

=== added file 'midori/CMakeLists.txt'
--- midori/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ midori/CMakeLists.txt	2013-09-01 12:21:28 +0000
@@ -0,0 +1,64 @@
+# Copyright (C) 2013 Christian Dywan <[e-mail]>
+
+set(LIBMIDORI_VERSION 0.5.5)
+set(LIBMIDORI_SOVERSION 0)
+
+file(GLOB MIDORI_VALA_SOURCE ../katze/*.vala *.vala ../panels/*.vala)
+file(GLOB LIBMIDORI_SOURCE ../katze/*.c ../panels/*.c ../toolbars/*.c midori-*.vala midori-*.c sokoke.c)
+include(GLibHelpers)
+add_glib_marshal(LIBMIDORI_SOURCE marshal ${CMAKE_PROJECT_NAME}_cclosure_marshal "midori.h")
+set(MIDORI_SOURCE
+    main.c
+    )
+
+include(ValaPrecompile)
+vala_precompile(LIBMIDORI_SOURCE_C ${CMAKE_PROJECT_NAME}
+    ${MIDORI_VALA_SOURCE}
+PACKAGES
+    ${PKGS}
+OPTIONS
+    ${VALAFLAGS}
+CUSTOM_VAPIS
+    ${EXTRA_VAPIS}
+GENERATE_VAPI
+    "${CMAKE_PROJECT_NAME}-core"
+GENERATE_HEADER
+    "${CMAKE_PROJECT_NAME}-core"
+)
+
+add_library(${LIBMIDORI} SHARED ${LIBMIDORI_SOURCE_C} ${LIBMIDORI_SOURCE})
+include_directories(
+                    ${CMAKE_SOURCE_DIR}
+                    ${CMAKE_CURRENT_SOURCE_DIR}
+                    "${CMAKE_SOURCE_DIR}/katze"
+                    "${CMAKE_SOURCE_DIR}/toolbars"
+                    ${CMAKE_BINARY_DIR}
+                    ${DEPS_INCLUDE_DIRS}
+                    ${OPTS_INCLUDE_DIRS}
+                    ${DEPS_GTK_INCLUDE_DIRS}
+                    ${OPTS_GTK_INCLUDE_DIRS}
+                    )
+target_link_libraries(${LIBMIDORI}
+                      ${DEPS_LIBRARIES}
+                      ${OPTS_LIBRARIES}
+                      ${DEPS_GTK_LIBRARIES}
+                      ${OPTS_GTK_LIBRARIES}
+                      )
+set_target_properties(${LIBMIDORI} PROPERTIES
+                      COMPILE_FLAGS ${CFLAGS}
+                      SOVERSION 1
+                      VERSION 0.0.0
+                      )
+install(TARGETS ${LIBMIDORI}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        )
+
+add_executable(${CMAKE_PROJECT_NAME} main.c)
+target_link_libraries(${CMAKE_PROJECT_NAME}
+                      ${LIBMIDORI})
+set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES
+                      COMPILE_FLAGS ${CFLAGS}
+                      )
+install(TARGETS ${CMAKE_PROJECT_NAME}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+        )

=== modified file 'midori/midori-browser.c'
--- midori/midori-browser.c	2013-08-15 21:32:30 +0000
+++ midori/midori-browser.c	2013-09-01 12:21:28 +0000
@@ -1553,6 +1553,32 @@
                          gboolean       user_initiated,
                          MidoriBrowser* browser)
 {
+    if (midori_tab_get_is_dialog (MIDORI_TAB (view)))
+    {
+        /* Dialog: URL, no toolbars, no tabs */
+        MidoriBrowser* new_browser;
+        g_signal_emit (browser, signals[NEW_WINDOW], 0, NULL, &new_browser);
+        g_assert (new_browser != NULL);
+        gtk_window_set_transient_for (GTK_WINDOW (new_browser), GTK_WINDOW (browser));
+        gtk_window_set_destroy_with_parent (GTK_WINDOW (new_browser), TRUE);
+        MidoriWebSettings* settings = midori_web_settings_new ();
+        g_object_set (settings,
+                      "toolbar-items", "Location",
+                      "show-menubar", FALSE,
+                      "show-bookmarkbar", FALSE,
+                      "show-statusbar", FALSE,
+                      NULL);
+        g_object_set (new_browser,
+                      "settings", settings,
+                      "show-tabs", FALSE,
+                      NULL);
+        g_object_unref (settings);
+        _action_set_visible (new_browser, "CompactMenu", FALSE);
+        midori_browser_add_tab (new_browser, new_view);
+        midori_browser_set_current_tab (new_browser, new_view);
+        return;
+    }
+
     if (midori_view_forward_external (new_view,
         katze_item_get_uri (midori_view_get_proxy_item (MIDORI_VIEW (new_view))),
         where))
@@ -6773,7 +6799,6 @@
     MidoriToolbarStyle toolbar_style;
     gchar* toolbar_items;
     gboolean close_buttons_on_tabs;
-    KatzeItem* item;
 
     g_object_get (browser->settings,
                   "remember-last-window-size", &remember_last_window_size,
@@ -6840,13 +6865,15 @@
     {
         const gchar* default_search = midori_settings_get_location_entry_search (
             MIDORI_SETTINGS (browser->settings));
-        item = katze_array_get_nth_item (browser->search_engines,
-                                         browser->last_web_search);
-        if (item)
+        KatzeItem* item;
+
+        if ((item = katze_array_get_nth_item (browser->search_engines,
+                                              browser->last_web_search)))
             midori_search_action_set_current_item (MIDORI_SEARCH_ACTION (
                 _action_by_name (browser, "Search")), item);
 
-        if ((item = katze_array_find_uri (browser->search_engines, default_search)))
+        if (default_search != NULL
+         && (item = katze_array_find_uri (browser->search_engines, default_search)))
             midori_search_action_set_default_item (MIDORI_SEARCH_ACTION (
                 _action_by_name (browser, "Search")), item);
     }

=== modified file 'midori/midori-tab.vala'
--- midori/midori-tab.vala	2013-07-28 15:50:26 +0000
+++ midori/midori-tab.vala	2013-09-01 12:21:28 +0000
@@ -92,6 +92,10 @@
        /* Since: 0.5.5 */
         public signal void context_menu (WebKit.HitTestResult hit_test_result, ContextAction menu);
 
+        /* A dialog tab has a fixed size, limited GUI and is transient.
+           Since: 0.5.6 */
+        public bool is_dialog { get; protected set; }
+
         public bool is_blank () {
             return URI.is_blank (uri);
         }

=== modified file 'midori/midori-view.c'
--- midori/midori-view.c	2013-09-01 12:20:28 +0000
+++ midori/midori-view.c	2013-09-01 12:21:28 +0000
@@ -2618,16 +2618,39 @@
 
 #ifndef HAVE_WEBKIT2
 static gboolean
+midori_view_web_view_close_cb (WebKitWebView* web_view,
+                               GtkWidget*     view)
+{
+    midori_browser_close_tab (midori_browser_get_for_widget (view), view);
+    return TRUE;
+}
+
+static gboolean
 webkit_web_view_web_view_ready_cb (GtkWidget*  web_view,
                                    MidoriView* view)
 {
     MidoriNewView where = MIDORI_NEW_VIEW_TAB;
     GtkWidget* new_view = GTK_WIDGET (midori_view_get_for_widget (web_view));
 
-    /* FIXME: Open windows opened by scripts in tabs if they otherwise
+    WebKitWebWindowFeatures* features = webkit_web_view_get_window_features (web_view);
+    gboolean locationbar_visible, menubar_visible, toolbar_visible;
+    gint width, height;
+    g_object_get (features,
+                  "locationbar-visible", &locationbar_visible,
+                  "menubar-visible", &menubar_visible,
+                  "toolbar-visible", &toolbar_visible,
+                  "width", &width,
+                  "height", &height,
+                  NULL);
+    midori_tab_set_is_dialog (MIDORI_TAB (view),
+     !locationbar_visible && !menubar_visible && !toolbar_visible
+     && width > 0 && height > 0);
+
+    /* Open windows opened by scripts in tabs if they otherwise
         would be replacing the page the user opened. */
     if (view->open_new_pages_in == MIDORI_NEW_PAGE_CURRENT)
-        return TRUE;
+        if (!midori_tab_get_is_dialog (MIDORI_TAB (view)))
+            return TRUE;
 
     if (view->open_new_pages_in == MIDORI_NEW_PAGE_TAB)
     {
@@ -2640,6 +2663,15 @@
     gtk_widget_show (new_view);
     g_signal_emit (view, signals[NEW_VIEW], 0, new_view, where, FALSE);
 
+    if (midori_tab_get_is_dialog (MIDORI_TAB (view)))
+    {
+        GtkWidget* toplevel = gtk_widget_get_toplevel (new_view);
+        if (width > 0 && height > 0)
+            gtk_widget_set_size_request (toplevel, width, height);
+        g_signal_connect (web_view, "close-web-view",
+                          G_CALLBACK (midori_view_web_view_close_cb), new_view);
+    }
+
     return TRUE;
 }
 
@@ -3954,6 +3986,10 @@
                 for (i = 0; i < G_N_ELEMENTS (widgets); i++)
                     g_string_append_printf (demo, widgets[i], " class=\"fallback\"");
                 g_string_append (demo, "</div>");
+                g_string_append (demo, "<p><a href=\"http://example.com\" target=\"wp\" "
+                                       "onclick=\"javascript:window.open('http://example.com','wp',"
+                                       "'width=320, height=240, toolbar=false'); return false\""
+                                       ">Popup window</a></p>");
                 data = g_string_free (demo, FALSE);
             }
             else if (!strcmp (uri, "about:private"))

=== added file 'po/CMakeLists.txt'
--- po/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ po/CMakeLists.txt	2013-09-01 12:21:28 +0000
@@ -0,0 +1,18 @@
+# Copyright (C) 2013 Christian Dywan <[e-mail]>
+
+include(FindGettext)
+if (GETTEXT_FOUND)
+    add_definitions("-DENABLE_NLS")
+    set(LANGUAGES $ENV{LINGUAS})
+    if (NOT LANGUAGES)
+        file(GLOB POTFILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*.po")
+        string(REPLACE ".po" " " LANGUAGES ${POTFILES})
+    endif ()
+    message(STATUS "gettext found: ${LANGUAGES}")
+    string(REPLACE " " ";" LANGUAGES ${LANGUAGES})
+    foreach(LANG ${LANGUAGES})
+        GETTEXT_PROCESS_PO_FILES(${LANG} ALL PO_FILES "${LANG}.po")
+    endforeach ()
+else ()
+    message(STATUS "gettext not found")
+endif ()

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2013-08-02 18:32:18 +0000
+++ po/POTFILES.in	2013-09-01 12:21:28 +0000
@@ -67,8 +67,6 @@
 katze/midori-hsts.vala
 katze/katze-separatoraction.vala
 katze/gtk3-compat.c
-katze/katze-http-cookies-sqlite.c
-katze/katze-http-cookies.c
 midori/socket.c
 midori/midori-panedaction.vala
 midori/midori-privatedata.c

=== added file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/CMakeLists.txt	2013-09-01 12:21:28 +0000
@@ -0,0 +1,65 @@
+# Copyright (C) 2013 Christian Dywan <[e-mail]>
+
+include(ContainTest)
+add_custom_target(check COMMAND "env" "CTEST_OUTPUT_ON_FAILURE=1" "${CMAKE_CTEST_COMMAND}")
+
+include_directories(
+                    "${CMAKE_SOURCE_DIR}"
+                    "${CMAKE_SOURCE_DIR}/midori"
+                    ${DEPS_INCLUDE_DIRS}
+                    ${OPTS_INCLUDE_DIRS}
+                    ${DEPS_GTK_INCLUDE_DIRS}
+                    ${OPTS_GTK_INCLUDE_DIRS}
+                    ${CMAKE_BINARY_DIR}
+                    "${CMAKE_BINARY_DIR}/midori"
+                    )
+file(GLOB TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.c)
+foreach(UNIT_SRC ${TESTS})
+    string(REPLACE ".c" "" UNIT ${UNIT_SRC})
+    add_executable(${UNIT} ${UNIT_SRC})
+    add_test(NAME ${UNIT} COMMAND ${UNIT})
+    contain_test(${UNIT})
+    target_link_libraries(${UNIT}
+                          ${LIBMIDORI}
+                          )
+    set_target_properties(${UNIT} PROPERTIES
+                          COMPILE_FLAGS ${CFLAGS}
+                          )
+endforeach ()
+
+file(GLOB TESTS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.vala)
+foreach(UNIT_SRC ${TESTS})
+    string(REPLACE ".vala" "" UNIT ${UNIT_SRC})
+    include(ValaPrecompile)
+    vala_precompile(UNIT_SRC_C ${UNIT}
+        ${UNIT_SRC}
+    PACKAGES
+        ${PKGS}
+    OPTIONS
+        ${VALAFLAGS}
+    CUSTOM_VAPIS
+        ${EXTRA_VAPIS}
+        "${CMAKE_SOURCE_DIR}/midori/midori.vapi"
+        "${CMAKE_SOURCE_DIR}/katze/katze.vapi"
+        "${CMAKE_BINARY_DIR}/midori/${LIBMIDORI}.vapi"
+    )
+    add_executable(${UNIT} ${UNIT_SRC_C})
+    add_test(NAME ${UNIT} COMMAND ${UNIT})
+    contain_test(${UNIT})
+    target_link_libraries(${UNIT}
+                          ${LIBMIDORI}
+                          )
+    set_target_properties(${UNIT} PROPERTIES
+                          COMPILE_FLAGS ${CFLAGS}
+                          )
+endforeach ()
+
+file(GLOB TESTS *.sh)
+foreach(UNIT_SRC ${TESTS})
+    string(REPLACE ".sh" "" UNIT ${UNIT_SRC})
+    add_test(NAME ${UNIT} COMMAND ${UNIT_SRC})
+    set_tests_properties(${UNIT} PROPERTIES
+                         ENVIRONMENT "SRCDIR=${CMAKE_SOURCE_DIR}"
+                         ENVIRONMENT "BLDDIR=${CMAKE_BINARY_DIR}"
+                         )
+endforeach ()