From 13465a27c62fd5e627aaca99265a46fef81be51a Mon Sep 17 00:00:00 2001 From: NotKit Date: Mon, 4 Sep 2017 20:09:53 +0300 Subject: [PATCH] Initial packaging for Maemo UI (#461) * Initial packaging for Maemo UI from https://github.com/fremantle-gtk2/ gtk+2.0-maemo package is based on https://pkgs.alpinelinux.org/package/edge/main/x86/gtk+2.0 by Natanael Copa * Include git revision in tarball filename --- maemo/gnome-menus2/APKBUILD | 27 + maemo/gtk+2.0-maemo/APKBUILD | 145 + maemo/gtk+2.0-maemo/automake.patch | 19 + .../gtk+2.0-maemo.post-deinstall | 7 + .../gtk+2.0-maemo/gtk+2.0-maemo.post-install | 5 + .../gtk+2.0-maemo/gtk+2.0-maemo.post-upgrade | 1 + .../gtk-update-icon-cache.trigger | 9 + maemo/gtk+2.0-maemo/gtk2-fixdso.patch | 15 + .../gtk+2.0-maemo/hildonize-gtk-treeview.diff | 3595 +++++++++++++++++ maemo/gtk+2.0-maemo/xid-collision-debug.patch | 15 + maemo/hildon-desktop/APKBUILD | 34 + maemo/hildon-theme-alpha/APKBUILD | 20 + maemo/iphbd/APKBUILD | 27 + maemo/libdsme/APKBUILD | 31 + maemo/libhildon/APKBUILD | 31 + maemo/libhildon/hildon-non-glibc.patch | 66 + maemo/libhildondesktop/APKBUILD | 26 + maemo/libmatchbox2/APKBUILD | 35 + maemo/maemo-l10n/APKBUILD | 294 ++ maemo/mce-headers/APKBUILD | 26 + maemo/profiled/APKBUILD | 27 + maemo/profiled/profiled-fix-musl.patch | 21 + 22 files changed, 4476 insertions(+) create mode 100644 maemo/gnome-menus2/APKBUILD create mode 100644 maemo/gtk+2.0-maemo/APKBUILD create mode 100644 maemo/gtk+2.0-maemo/automake.patch create mode 100644 maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-deinstall create mode 100644 maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-install create mode 120000 maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-upgrade create mode 100644 maemo/gtk+2.0-maemo/gtk-update-icon-cache.trigger create mode 100644 maemo/gtk+2.0-maemo/gtk2-fixdso.patch create mode 100644 maemo/gtk+2.0-maemo/hildonize-gtk-treeview.diff create mode 100644 maemo/gtk+2.0-maemo/xid-collision-debug.patch create mode 100644 maemo/hildon-desktop/APKBUILD create mode 100644 maemo/hildon-theme-alpha/APKBUILD create mode 100644 maemo/iphbd/APKBUILD create mode 100644 maemo/libdsme/APKBUILD create mode 100644 maemo/libhildon/APKBUILD create mode 100644 maemo/libhildon/hildon-non-glibc.patch create mode 100644 maemo/libhildondesktop/APKBUILD create mode 100644 maemo/libmatchbox2/APKBUILD create mode 100644 maemo/maemo-l10n/APKBUILD create mode 100644 maemo/mce-headers/APKBUILD create mode 100644 maemo/profiled/APKBUILD create mode 100644 maemo/profiled/profiled-fix-musl.patch diff --git a/maemo/gnome-menus2/APKBUILD b/maemo/gnome-menus2/APKBUILD new file mode 100644 index 000000000..b1ad05e9f --- /dev/null +++ b/maemo/gnome-menus2/APKBUILD @@ -0,0 +1,27 @@ +pkgname=gnome-menus2 +pkgver=3.0.1 +pkgrel=1 +pkgdesc='Library for the Desktop Menu Specification (legacy version)' +arch="all" +url='http://www.gnome.org/' +license="LGPL" +depends="glib" +makedepends="gobject-introspection intltool python-dev" +subpackages="$pkgname-dev" +source="http://ftp.gnome.org/pub/gnome/sources/${pkgname%2}/${pkgver%.*}/${pkgname%2}-${pkgver}.tar.bz2" + +build() { + cd "$srcdir/${pkgname%2}-$pkgver" + + export PYTHON='/usr/bin/python2' + ./configure --prefix='/usr' --sysconfdir='/etc' --localstatedir='/var' --disable-static + make +} + +package(){ + cd "$srcdir/${pkgname%2}-$pkgver" + + make -C libmenu DESTDIR="${pkgdir}" install + make -C python DESTDIR="${pkgdir}" install +} +sha512sums="05eda56b741d7236b17276b3b208b8370ec8ff0db82e32a2c0adb84334c4d9365fe61dea08183858fb7c0093cf04a02ba1311483e3318dbe816a02c28f4198eb gnome-menus-3.0.1.tar.bz2" diff --git a/maemo/gtk+2.0-maemo/APKBUILD b/maemo/gtk+2.0-maemo/APKBUILD new file mode 100644 index 000000000..696a8e69d --- /dev/null +++ b/maemo/gtk+2.0-maemo/APKBUILD @@ -0,0 +1,145 @@ +pkgname=gtk+2.0-maemo +pkgver=2.24.31 +pkgrel=0 +subpkg=gtk-update-icon-cache +pkgdesc="The GTK+ Toolkit (v2)" +url="http://www.gtk.org/" +install="$pkgname.post-install $pkgname.post-upgrade $pkgname.post-deinstall" +triggers="$subpkg.trigger=/usr/share/icons/*" +arch="all" +license="LGPL" +subpackages="$pkgname-dev $pkgname-doc $pkgname-lang $subpkg:icon_cache" +depends="shared-mime-info gtk-update-icon-cache" + +replaces="gtk+ gtk+-dev gtk+-doc" +provides="gtk+2.0=$pkgver gtk+2.0-dev=$pkgver gtk+2.0-doc=$pkgver" + +depends_dev=" + atk-dev + cairo-dev + intltool + libxdamage-dev + pango-dev + " +# we add hicolor-icon-theme because the subpackage gtk-update-icon-cache +# needs it. We need to force hicolor-icon-cache to be built before gtk+.2.0 +makedepends=" + autoconf automake libtool + $depends_dev + cups-dev + expat-dev + gdk-pixbuf-dev + gettext-dev + glib-dev + gnutls-dev + gobject-introspection-dev + gtk-doc + hicolor-icon-theme + libice-dev + libx11-dev + libxcomposite-dev + libxcursor-dev + libxext-dev + libxfixes-dev + libxrandr-dev + libxi-dev + zlib-dev" +source="http://ftp.gnome.org/pub/gnome/sources/gtk+/${pkgver%.*}/gtk+-$pkgver.tar.xz + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gdk-window.diff + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gtk-container.diff + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gtk-dialog.diff + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gtk-entry.diff + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gtk-enums.diff + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gtk-iconview.diff + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gtk-imcontext.diff + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gtk-menu.diff + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gtk-rbtree.diff + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gtk-textview.diff + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gtk-widget.diff + https://raw.githubusercontent.com/fremantle-gtk2/gtk/2.24.25-3m7%2Bmaemo/debian/patches/hildonize-gtk-window.diff + xid-collision-debug.patch + gtk2-fixdso.patch + hildonize-gtk-treeview.diff + $install" + + +_builddir="$srcdir"/gtk+-$pkgver +prepare() { + local i + local filename + + cd "$_builddir" + for i in $source; do + case $i in + *.patch | *.diff) + filename=`basename "$i"` + msg $filename + patch -p1 -i "$srcdir/$filename" || return 1 + ;; + esac + done + + libtoolize --force \ + && aclocal -I m4 \ + && autoconf \ + && automake --add-missing +} + +build() { + cd "$_builddir" + ./configure \ + --build=$CBUILD \ + --host=$CHOST \ + --prefix=/usr \ + --sysconfdir=/etc \ + --localstatedir=/var \ + --with-xinput=yes \ + --without-libjasper \ + --with-included-loaders=png \ + || return 1 + # https://bugzilla.gnome.org/show_bug.cgi?id=655517 + sed -i -e 's/ -shared / -Wl,-O1,--as-needed\0/g' libtool || return 1 + make || return 1 +} + +package() { + cd "$_builddir" + make DESTDIR="$pkgdir" install || return 1 +} + +dev() { + mkdir -p "$subpkgdir"/usr/bin "$subpkgdir"/usr/share/ + mv "$pkgdir"/usr/share/gtk-2.0 "$subpkgdir"/usr/share/ || return 1 + default_dev + replaces="gtk+2.0" + mv "$pkgdir"/usr/bin/gtk-builder-convert \ + "$pkgdir"/usr/bin/gtk-demo \ + "$subpkgdir"/usr/bin || return 1 +} + +icon_cache() { + depends="hicolor-icon-theme" + + mkdir -p "$subpkgdir"/usr/bin + mv "$pkgdir"/usr/bin/"$subpkg" "$subpkgdir"/usr/bin || return 1 +} + +sha512sums="75b846661308d94b5236e7e1c367deabf57753792ca87e92f9769822dd5ec90e00cd8d5574adcc12162e3702e1ae6dc152278a1d218f9bd9e4d1c8dc1dd520c1 gtk+-2.24.31.tar.xz +f838b74958b4f5f1f37fb2831c07dfb7ea051fd62c74f17d8848736e1bbd5671b9a8a66e5a34ce131669a05b2e99312fa43a91ef1d456a914f2d308c09412681 hildonize-gdk-window.diff +809135f8921bf42c0684be6183eb626ec21db87ead3cb3efbfb59d1b6c57f6d2bc61f23cdf54ed6521de1a74c606ed69cb9991332edb938b076baecd805154b2 hildonize-gtk-container.diff +77c37f91e989b9e6326b9b2c1bf32f5feaa7b81ec5742f5fb1c5b6db07de4efcc9753beadb9517fe8e04983e11d122b5dfd94897bc8bdb2d68cf7dfffdb1b46e hildonize-gtk-dialog.diff +29ea967378c84e907f7a102bcf6cd893c12c25586c95b2a2994e92dd1f1e82996bfb1416cef47a17ff6b8a225a222cd545b2080d45d190d9061a0f1ecf2baf37 hildonize-gtk-entry.diff +a65dc9a3f5e2967d382d8f13781bf446441bea23d84740eaf43e4ce7ee14b3592b7f105f4b89b7246c42f5be9a9e1e9ae93ac23bc6b62ae9c09b45a0eb6a273d hildonize-gtk-enums.diff +44ba4adcd50c589990af195d3b25baed8098ef8f7f191d841b9ce86bf7e65a48c4e8222a755eca1373eaabe6a79db9c3721f0fa690cca5e5e31fd9b4c3fc69bb hildonize-gtk-iconview.diff +ece16de21b19ccb7b08bad78880fa83765bb562973cf73249a9b2b617e0918e231d54bf64ee82648901c7f6c4af4220b06547dc9a17bbb77fab9e83c08cdcfe7 hildonize-gtk-imcontext.diff +44cd0f71316f38da52ad0e9db3681bf4fbf83c9175b98bb9241d0bedf3f66ed6923c8aa6c9c26264ee4d7b5f8abb15f2ab7cd9f1eaf037273bf94ec50ff4ea41 hildonize-gtk-menu.diff +d664555b7e7a98a567548d403e3df0d0534312ba6947d422a0d68dddbaa786806a842a25dcb5f4a0e1235a2f64d6920f67bf93b4574540d4af2337e1d5b68f2c hildonize-gtk-rbtree.diff +f4c1978b1cbd00cc28779f1cda99434f2f5aec53fd6564282d7d2c5ac5d4869207d38a31ad971bfa09eefe5a78030b3c4c169cbdbd7f5e3b2f7c42bed7f58e56 hildonize-gtk-textview.diff +aa3100404b4fe4509ec52c79384e5e59585d482947e394ad26f9c83ad11c9a19f2b0f66112ba9c74feb7a0c7d1b5ec54c64fac34ec0c03666b3ecb62160db8b6 hildonize-gtk-widget.diff +7622b5ff6cd1c0705eee7ad5789c675055a79a4b0aaf2f25fdab4a6fdf883e6fbdef22145d2f2ce4ada3015bd7a8424f61a325a8d00c80e26bf1b507c7949318 hildonize-gtk-window.diff +89e3223c86731a76b12d39245f1ec4cf8b4860ab1d11d74a10e5deb0db302f20b4bb5d9034da1d8aeb96369dbdeddcdd2f28943270dc501476c694562b960159 xid-collision-debug.patch +95f28633a5164a2a9fec45ee1aa80bd1c07e0c5a7ac8d770b9c74af0909b7286b823eb634aa384cad609dc8799d2e6c9e8392c2732b9093076fdf94b4f6878b7 gtk2-fixdso.patch +87bdabbbbf41469abf67f53afd77edbe69ce41638c1bc3cfb049864e5105fc565dfdbacd0f95381f2a9e2225d18b1c57a5a1e2c77846c3aca1a09e6dea334b8d hildonize-gtk-treeview.diff +3f2a85b13e98a4a3afd39ca619a5236f3b3961c8923fc75dce70ad6e1517557557b1eeba172631d248268fce5859ae03b5906a4f8fdcea62c01ccdd1d6d2f1ab gtk+2.0-maemo.post-install +3f2a85b13e98a4a3afd39ca619a5236f3b3961c8923fc75dce70ad6e1517557557b1eeba172631d248268fce5859ae03b5906a4f8fdcea62c01ccdd1d6d2f1ab gtk+2.0-maemo.post-upgrade +eb2cd05d410b2710f70c7a84b2ee429b104564f5812d29bb4dfed23447a9fe4505b92f096af120e1804b55f73c8f5fcfd26f4d209700783a80f00361d7f1681b gtk+2.0-maemo.post-deinstall" diff --git a/maemo/gtk+2.0-maemo/automake.patch b/maemo/gtk+2.0-maemo/automake.patch new file mode 100644 index 000000000..106597974 --- /dev/null +++ b/maemo/gtk+2.0-maemo/automake.patch @@ -0,0 +1,19 @@ +--- ./configure.in.orig 2012-12-31 14:40:30.297439517 +0000 ++++ ./configure.in 2012-12-31 14:40:51.587629835 +0000 +@@ -51,7 +51,7 @@ + cflags_set=${CFLAGS+set} + + AM_INIT_AUTOMAKE([no-define -Wno-portability dist-bzip2]) +-AM_CONFIG_HEADER(config.h) ++AC_CONFIG_HEADER(config.h) + + # Support silent build rules, requires at least automake-1.11. Enable + # by either passing --enable-silent-rules to configure or passing V=0 +@@ -300,7 +300,6 @@ + + # Checks for programs. + AC_ISC_POSIX +-AM_PROG_CC_STDC + AM_PROG_CC_C_O + AC_PROG_INSTALL + AC_PROG_MAKE_SET diff --git a/maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-deinstall b/maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-deinstall new file mode 100644 index 000000000..ea39aa8bf --- /dev/null +++ b/maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-deinstall @@ -0,0 +1,7 @@ +#!/bin/sh + +# since we depend on coreutils and busybox trigger has not yet run, we +# use busybox directly as workaround +/bin/busybox rm -f etc/gtk-2.0/gtk.immodules +/bin/busybox rm -f etc/gtk-2.0/gdk-pixbuf.loaders + diff --git a/maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-install b/maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-install new file mode 100644 index 000000000..80444cfb9 --- /dev/null +++ b/maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-install @@ -0,0 +1,5 @@ +#!/bin/sh + +usr/bin/gtk-query-immodules-2.0 > etc/gtk-2.0/gtk.immodules +usr/bin/gdk-pixbuf-query-loaders > etc/gtk-2.0/gdk-pixbuf.loaders + diff --git a/maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-upgrade b/maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-upgrade new file mode 120000 index 000000000..67250f726 --- /dev/null +++ b/maemo/gtk+2.0-maemo/gtk+2.0-maemo.post-upgrade @@ -0,0 +1 @@ +gtk+2.0-maemo.post-install \ No newline at end of file diff --git a/maemo/gtk+2.0-maemo/gtk-update-icon-cache.trigger b/maemo/gtk+2.0-maemo/gtk-update-icon-cache.trigger new file mode 100644 index 000000000..a106f5f08 --- /dev/null +++ b/maemo/gtk+2.0-maemo/gtk-update-icon-cache.trigger @@ -0,0 +1,9 @@ +#!/bin/sh + +for i in "$@"; do + if ! [ -e "$i" ]; then + continue + fi + gtk-update-icon-cache -q -t -f "$i" +done + diff --git a/maemo/gtk+2.0-maemo/gtk2-fixdso.patch b/maemo/gtk+2.0-maemo/gtk2-fixdso.patch new file mode 100644 index 000000000..3ea784699 --- /dev/null +++ b/maemo/gtk+2.0-maemo/gtk2-fixdso.patch @@ -0,0 +1,15 @@ +--- gtk+-2.24.8/gtk/Makefile.am.orig 2012-02-01 11:14:25.468115547 +0000 ++++ gtk+-2.24.8/gtk/Makefile.am 2012-02-01 11:14:57.920116650 +0000 +@@ -904,10 +904,10 @@ + libgtk_quartz_2_0_la_SOURCES = $(gtk_c_sources) + libgtk_directfb_2_0_la_SOURCES = $(gtk_c_sources) + +-libgtk_x11_2_0_la_LDFLAGS = $(libtool_opts) ++libgtk_x11_2_0_la_LDFLAGS = $(libtool_opts) -lgmodule-2.0 + libgtk_win32_2_0_la_LDFLAGS = $(libtool_opts) -Wl,-luuid + libgtk_quartz_2_0_la_LDFLAGS = $(libtool_opts) +-libgtk_directfb_2_0_la_LDFLAGS = $(libtool_opts) ++libgtk_directfb_2_0_la_LDFLAGS = $(libtool_opts) -lgmodule-2.0 + + libgtk_x11_2_0_la_LIBADD = $(libadd) + libgtk_win32_2_0_la_LIBADD = $(libadd) -lole32 -lgdi32 -lcomdlg32 -lwinspool -lcomctl32 diff --git a/maemo/gtk+2.0-maemo/hildonize-gtk-treeview.diff b/maemo/gtk+2.0-maemo/hildonize-gtk-treeview.diff new file mode 100644 index 000000000..0ceb50cea --- /dev/null +++ b/maemo/gtk+2.0-maemo/hildonize-gtk-treeview.diff @@ -0,0 +1,3595 @@ +--- a/gtk/gtktreeview.c ++++ b/gtk/gtktreeview.c +@@ -43,6 +43,8 @@ + #include "gtkframe.h" + #include "gtktreemodelsort.h" + #include "gtktooltip.h" ++#include "gtkicontheme.h" ++#include "gtkeventbox.h" + #include "gtkprivate.h" + #include "gtkalias.h" + +@@ -54,6 +56,9 @@ + #define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000 + #define AUTO_EXPAND_TIMEOUT 500 + ++#define HILDON_TICK_MARK_SIZE 48 ++#define HILDON_ROW_HEADER_HEIGHT 35 ++ + /* The "background" areas of all rows/cells add up to cover the entire tree. + * The background includes all inter-row and inter-cell spacing. + * The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(), +@@ -120,6 +125,8 @@ + EXPAND_COLLAPSE_CURSOR_ROW, + SELECT_CURSOR_PARENT, + START_INTERACTIVE_SEARCH, ++ ROW_INSENSITIVE, ++ HILDON_ROW_TAPPED, + LAST_SIGNAL + }; + +@@ -144,7 +151,10 @@ + PROP_RUBBER_BANDING, + PROP_ENABLE_GRID_LINES, + PROP_ENABLE_TREE_LINES, +- PROP_TOOLTIP_COLUMN ++ PROP_TOOLTIP_COLUMN, ++ PROP_HILDON_UI_MODE, ++ PROP_ACTION_AREA_VISIBLE, ++ PROP_ACTION_AREA_ORIENTATION + }; + + /* object signals */ +@@ -478,9 +488,16 @@ + static void add_scroll_timeout (GtkTreeView *tree_view); + static void remove_scroll_timeout (GtkTreeView *tree_view); + +-static guint tree_view_signals [LAST_SIGNAL] = { 0 }; ++static gboolean gtk_tree_view_tap_and_hold_query (GtkWidget *widget, ++ GdkEvent *event); ++static void free_queued_select_row (GtkTreeView *tree_view); ++static void free_queued_activate_row (GtkTreeView *tree_view); ++static void free_queued_actions (GtkTreeView *tree_view); + +- ++static void hildon_tree_view_set_action_area_height (GtkTreeView *tree_view); ++static void hildon_tree_view_setup_row_header_layout (GtkTreeView *tree_view); ++ ++static guint tree_view_signals [LAST_SIGNAL] = { 0 }; + + /* GType Methods + */ +@@ -544,6 +561,12 @@ + widget_class->grab_notify = gtk_tree_view_grab_notify; + widget_class->state_changed = gtk_tree_view_state_changed; + ++ g_signal_override_class_closure (g_signal_lookup ("tap-and-hold-query", ++ GTK_TYPE_WIDGET), ++ GTK_TYPE_TREE_VIEW, ++ g_cclosure_new (G_CALLBACK (gtk_tree_view_tap_and_hold_query), ++ NULL, NULL)); ++ + /* GtkContainer signals */ + container_class->remove = gtk_tree_view_remove; + container_class->forall = gtk_tree_view_forall; +@@ -715,7 +738,7 @@ + g_param_spec_boolean ("show-expanders", + P_("Show Expanders"), + P_("View has expanders"), +- TRUE, ++ FALSE, + GTK_PARAM_READWRITE)); + + /** +@@ -732,7 +755,7 @@ + P_("Extra indentation for each level"), + 0, + G_MAXINT, +- 0, ++ 10, + GTK_PARAM_READWRITE)); + + g_object_class_install_property (o_class, +@@ -740,7 +763,7 @@ + g_param_spec_boolean ("rubber-banding", + P_("Rubber Banding"), + P_("Whether to enable selection of multiple items by dragging the mouse pointer"), +- FALSE, ++ TRUE, + GTK_PARAM_READWRITE)); + + g_object_class_install_property (o_class, +@@ -770,10 +793,73 @@ + -1, + GTK_PARAM_READWRITE)); + ++ /** ++ * GtkTreeView:hildon-ui-mode: ++ * ++ * Specifies which UI mode to use. A setting of #HILDON_UI_MODE_NORMAL ++ * will cause the tree view to disable selections and emit row-activated ++ * as soon as a row is pressed. When #HILDON_UI_MODE_EDIT is set, ++ * selections can be made according to the setting of the mode on ++ * GtkTreeSelection. ++ * ++ * Toggling this property will cause the tree view to select an ++ * appropriate selection mode if not already done. ++ * ++ * Since: maemo 5.0 ++ * Stability: unstable ++ */ ++ g_object_class_install_property (o_class, ++ PROP_HILDON_UI_MODE, ++ g_param_spec_enum ("hildon-ui-mode", ++ P_("Hildon UI Mode"), ++ P_("The Hildon UI mode according to which the tree view should behave"), ++ HILDON_TYPE_UI_MODE, ++ HILDON_UI_MODE_NORMAL, ++ GTK_PARAM_READWRITE)); ++ ++ /** ++ * GtkTreeView:action-area-visible: ++ * ++ * Makes the action area of the GtkTreeView visible or invisible. ++ * Based on the value of the GtkTreeView:action-area-orientation ++ * property a certain height will be allocated above the first row ++ * for the action area. ++ * ++ * Since: maemo 5.0 ++ * Stability: unstable ++ */ ++ g_object_class_install_property (o_class, ++ PROP_ACTION_AREA_VISIBLE, ++ g_param_spec_boolean ("action-area-visible", ++ P_("Action Area Visible"), ++ P_("Whether the action area above the first row is visible"), ++ FALSE, ++ GTK_PARAM_READWRITE)); ++ ++ /** ++ * GtkTreeView:action-area-orientation: ++ * ++ * Sets the orientation of the action area. This is either ++ * horizontal (landscape) or vertical (portrait). The height of ++ * the action area depends on this setting. ++ * ++ * Since: maemo 5.0 ++ * Stability: unstable ++ */ ++ g_object_class_install_property (o_class, ++ PROP_ACTION_AREA_ORIENTATION, ++ g_param_spec_enum ("action-area-orientation", ++ P_("Action Area Orientation"), ++ P_("Determines the orientation of the action area."), ++ GTK_TYPE_ORIENTATION, ++ GTK_ORIENTATION_HORIZONTAL, ++ GTK_PARAM_READWRITE)); ++ + /* Style properties */ + #define _TREE_VIEW_EXPANDER_SIZE 12 + #define _TREE_VIEW_VERTICAL_SEPARATOR 2 + #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2 ++#define _TREE_VIEW_SEPARATOR_HEIGHT 2 + + gtk_widget_class_install_style_property (widget_class, + g_param_spec_int ("expander-size", +@@ -872,6 +958,43 @@ + "\1\1", + GTK_PARAM_READABLE)); + ++ /** ++ * GtkTreeView:separator-height: ++ * ++ * Height in pixels of a separator. ++ * ++ * Since: maemo 3.0 ++ * Stability: Unstable ++ */ ++ gtk_widget_class_install_style_property (widget_class, ++ g_param_spec_int ("separator-height", ++ P_("Separator height"), ++ P_("Height of the separator"), ++ 0, ++ G_MAXINT, ++ _TREE_VIEW_SEPARATOR_HEIGHT, ++ GTK_PARAM_READABLE)); ++ ++ /** ++ * GtkTreeView:row-height: ++ * ++ * Height in pixels of a row. When set, all rows will use this height, ++ * except for row separators and row headers. A value of -1 means this ++ * value is unset. Setting this property does not imply fixed height ++ * mode will be turned on, so columns are still properly autosized. ++ * ++ * Since: maemo 5.0 ++ * Stability: Unstable ++ */ ++ gtk_widget_class_install_style_property (widget_class, ++ g_param_spec_int ("row-height", ++ P_("Row height"), ++ P_("Height of a row"), ++ -1, ++ G_MAXINT, ++ -1, ++ GTK_PARAM_READABLE)); ++ + /* Signals */ + /** + * GtkTreeView::set-scroll-adjustments +@@ -1109,6 +1232,36 @@ + _gtk_marshal_BOOLEAN__VOID, + G_TYPE_BOOLEAN, 0); + ++ /** ++ * GtkTreeView::row-insensitive: ++ * @tree_view: the object which received the signal. ++ * @path: the path where the cursor is tried to be moved. ++ * ++ * Emitted when the user tries to move cursor to an insesitive row. ++ * ++ * Since: maemo 1.0 ++ * Stability: Unstable ++ */ ++ tree_view_signals[ROW_INSENSITIVE] = ++ g_signal_new ("row_insensitive", ++ G_TYPE_FROM_CLASS (o_class), ++ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, ++ G_STRUCT_OFFSET (GtkTreeViewClass, row_insensitive), ++ NULL, NULL, ++ _gtk_marshal_VOID__OBJECT, ++ G_TYPE_NONE, 1, ++ GTK_TYPE_TREE_PATH); ++ ++ tree_view_signals[HILDON_ROW_TAPPED] = ++ g_signal_new ("hildon_row_tapped", ++ G_TYPE_FROM_CLASS (o_class), ++ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, ++ 0, ++ NULL, NULL, ++ _gtk_marshal_VOID__BOXED, ++ G_TYPE_NONE, 1, ++ GTK_TYPE_TREE_PATH); ++ + /* Key bindings */ + gtk_tree_view_add_move_binding (binding_set, GDK_Up, 0, TRUE, + GTK_MOVEMENT_DISPLAY_LINES, -1); +@@ -1333,9 +1486,7 @@ + gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE); + gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE); + +- tree_view->priv->flags = GTK_TREE_VIEW_SHOW_EXPANDERS +- | GTK_TREE_VIEW_DRAW_KEYFOCUS +- | GTK_TREE_VIEW_HEADERS_VISIBLE; ++ tree_view->priv->flags = GTK_TREE_VIEW_DRAW_KEYFOCUS; + + /* We need some padding */ + tree_view->priv->dy = 0; +@@ -1368,9 +1519,27 @@ + tree_view->priv->hover_selection = FALSE; + tree_view->priv->hover_expand = FALSE; + +- tree_view->priv->level_indentation = 0; ++ tree_view->priv->level_indentation = 10; ++ ++ tree_view->priv->queued_select_row = NULL; ++ tree_view->priv->queued_expand_row = NULL; ++ tree_view->priv->queued_activate_row = NULL; ++ tree_view->priv->queued_tapped_row = NULL; ++ ++ tree_view->priv->highlighted_node = NULL; ++ tree_view->priv->highlighted_tree = NULL; ++ ++ tree_view->priv->queued_ctrl_pressed = FALSE; ++ tree_view->priv->queued_shift_pressed = FALSE; ++ ++ tree_view->priv->hildon_ui_mode = HILDON_UI_MODE_NORMAL; ++ gtk_widget_style_get (GTK_WIDGET (tree_view), ++ "hildon-mode", &tree_view->priv->hildon_mode, ++ NULL); + +- tree_view->priv->rubber_banding_enable = FALSE; ++ tree_view->priv->level_indentation = 10; ++ ++ tree_view->priv->rubber_banding_enable = TRUE; + + tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE; + tree_view->priv->tree_lines_enabled = FALSE; +@@ -1384,9 +1553,13 @@ + + tree_view->priv->event_last_x = -10000; + tree_view->priv->event_last_y = -10000; +-} + +- ++ tree_view->priv->rows_offset = 0; ++ tree_view->priv->action_area_visible = FALSE; ++ tree_view->priv->action_area_orientation = GTK_ORIENTATION_HORIZONTAL; ++ tree_view->priv->action_area_event_box = NULL; ++ tree_view->priv->action_area_box = NULL; ++} + + /* GObject Methods + */ +@@ -1460,6 +1633,15 @@ + case PROP_TOOLTIP_COLUMN: + gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value)); + break; ++ case PROP_HILDON_UI_MODE: ++ hildon_tree_view_set_hildon_ui_mode (tree_view, g_value_get_enum (value)); ++ break; ++ case PROP_ACTION_AREA_VISIBLE: ++ hildon_tree_view_set_action_area_visible (tree_view, g_value_get_boolean (value)); ++ break; ++ case PROP_ACTION_AREA_ORIENTATION: ++ hildon_tree_view_set_action_area_orientation (tree_view, g_value_get_enum (value)); ++ break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; +@@ -1535,6 +1717,15 @@ + case PROP_TOOLTIP_COLUMN: + g_value_set_int (value, tree_view->priv->tooltip_column); + break; ++ case PROP_HILDON_UI_MODE: ++ g_value_set_enum (value, tree_view->priv->hildon_ui_mode); ++ break; ++ case PROP_ACTION_AREA_VISIBLE: ++ g_value_set_boolean (value, tree_view->priv->action_area_visible); ++ break; ++ case PROP_ACTION_AREA_ORIENTATION: ++ g_value_set_enum (value, tree_view->priv->action_area_orientation); ++ break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; +@@ -1595,6 +1786,8 @@ + tree_view->priv->prelight_node = NULL; + tree_view->priv->expanded_collapsed_node = NULL; + tree_view->priv->expanded_collapsed_tree = NULL; ++ tree_view->priv->highlighted_node = NULL; ++ tree_view->priv->highlighted_tree = NULL; + } + + static void +@@ -1650,6 +1843,30 @@ + tree_view->priv->top_row = NULL; + } + ++ if (tree_view->priv->queued_select_row != NULL) ++ { ++ gtk_tree_row_reference_free (tree_view->priv->queued_select_row); ++ tree_view->priv->queued_select_row = NULL; ++ } ++ ++ if (tree_view->priv->queued_expand_row != NULL) ++ { ++ gtk_tree_row_reference_free (tree_view->priv->queued_expand_row); ++ tree_view->priv->queued_expand_row = NULL; ++ } ++ ++ if (tree_view->priv->queued_activate_row != NULL) ++ { ++ gtk_tree_row_reference_free (tree_view->priv->queued_activate_row); ++ tree_view->priv->queued_activate_row = NULL; ++ } ++ ++ if (tree_view->priv->queued_tapped_row != NULL) ++ { ++ gtk_tree_row_reference_free (tree_view->priv->queued_tapped_row); ++ tree_view->priv->queued_tapped_row = NULL; ++ } ++ + if (tree_view->priv->column_drop_func_data && + tree_view->priv->column_drop_func_data_destroy) + { +@@ -1701,6 +1918,24 @@ + tree_view->priv->row_separator_data = NULL; + } + ++ if (tree_view->priv->row_header_destroy && tree_view->priv->row_header_data) ++ { ++ (* tree_view->priv->row_header_destroy) (tree_view->priv->row_header_data); ++ tree_view->priv->row_header_data = NULL; ++ } ++ ++ if (tree_view->priv->row_header_layout) ++ { ++ g_object_unref (tree_view->priv->row_header_layout); ++ tree_view->priv->row_header_layout = NULL; ++ } ++ ++ if (tree_view->priv->tickmark_icon) ++ { ++ g_object_unref (tree_view->priv->tickmark_icon); ++ tree_view->priv->tickmark_icon = NULL; ++ } ++ + gtk_tree_view_set_model (tree_view, NULL); + + if (tree_view->priv->hadjustment) +@@ -2036,7 +2271,7 @@ + if (tree_view->priv->tree == NULL) + tree_view->priv->height = 0; + else +- tree_view->priv->height = tree_view->priv->tree->root->offset; ++ tree_view->priv->height = tree_view->priv->tree->root->offset + tree_view->priv->rows_offset; + } + + static void +@@ -2228,6 +2463,13 @@ + number_of_expand_columns++; + } + ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT ++ && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE) ++ { ++ full_requested_width += HILDON_TICK_MARK_SIZE; ++ } ++ + /* Only update the expand value if the width of the widget has changed, + * or the number of expand columns has changed, or if there are no expand + * columns, or if we didn't have an size-allocation yet after the +@@ -2381,6 +2623,17 @@ + allocation.y = child->y; + allocation.width = child->width; + allocation.height = child->height; ++ ++ if (tree_view->priv->rows_offset != 0 ++ && tree_view->priv->action_area_event_box == child->widget) ++ { ++ /* Set the child's location to be the area above the first row */ ++ allocation.x = 0; ++ allocation.y = -tree_view->priv->dy; ++ allocation.width = MAX (widget->allocation.width, tree_view->priv->width); ++ allocation.height = tree_view->priv->rows_offset; ++ } ++ + gtk_widget_size_allocate (child->widget, &allocation); + } + +@@ -2521,25 +2774,41 @@ + static inline gboolean + row_is_separator (GtkTreeView *tree_view, + GtkTreeIter *iter, ++ gboolean *is_header, + GtkTreePath *path) + { + gboolean is_separator = FALSE; ++ GtkTreeIter tmpiter; + +- if (tree_view->priv->row_separator_func) ++ if (tree_view->priv->row_separator_func ++ || tree_view->priv->row_header_func) + { +- GtkTreeIter tmpiter; +- + if (iter) +- tmpiter = *iter; ++ tmpiter = *iter; + else +- { +- if (!gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path)) +- return FALSE; +- } ++ gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path); ++ } + +- is_separator = tree_view->priv->row_separator_func (tree_view->priv->model, +- &tmpiter, +- tree_view->priv->row_separator_data); ++ if (tree_view->priv->row_separator_func) ++ { ++ is_separator = (* tree_view->priv->row_separator_func) (tree_view->priv->model, ++ &tmpiter, ++ tree_view->priv->row_separator_data); ++ } ++ ++ if (tree_view->priv->row_header_func) ++ { ++ gboolean tmp; ++ ++ tmp = (* tree_view->priv->row_header_func) (tree_view->priv->model, ++ &tmpiter, ++ NULL, ++ tree_view->priv->row_header_data); ++ ++ is_separator |= tmp; ++ ++ if (is_header) ++ *is_header = tmp; + } + + return is_separator; +@@ -2589,6 +2858,7 @@ + gboolean row_double_click = FALSE; + gboolean rtl; + gboolean node_selected; ++ gboolean node_is_selectable; + + /* Empty tree? */ + if (tree_view->priv->tree == NULL) +@@ -2633,7 +2903,7 @@ + + /* Get the path and the node */ + path = _gtk_tree_view_find_path (tree_view, tree, node); +- path_is_selectable = !row_is_separator (tree_view, NULL, path); ++ path_is_selectable = !row_is_separator (tree_view, NULL, NULL, path); + + if (!path_is_selectable) + { +@@ -2689,6 +2959,17 @@ + break; + } + ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT ++ && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE ++ && (gint)event->x < background_area.x + HILDON_TICK_MARK_SIZE) ++ { ++ GList *list; ++ ++ list = (rtl ? g_list_first (tree_view->priv->columns) : g_list_last (tree_view->priv->columns)); ++ column = list->data; ++ } ++ + if (column == NULL) + { + gtk_tree_path_free (path); +@@ -2765,6 +3046,39 @@ + gtk_tree_path_free (anchor); + } + ++ node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED); ++ node_is_selectable = ++ _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, ++ node, path); ++ ++ /* Save press to possibly begin a drag ++ */ ++ if (!column_handled_click && ++ !tree_view->priv->in_grab && ++ tree_view->priv->pressed_button < 0) ++ { ++ tree_view->priv->pressed_button = event->button; ++ tree_view->priv->press_start_x = event->x; ++ tree_view->priv->press_start_y = event->y; ++ ++ if (tree_view->priv->hildon_mode == HILDON_DIABLO ++ && tree_view->priv->rubber_banding_enable ++ && node_is_selectable ++ && !node_selected ++ && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE) ++ { ++ tree_view->priv->press_start_y += tree_view->priv->dy; ++ tree_view->priv->rubber_band_x = event->x; ++ tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy; ++ tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START; ++ ++ if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) ++ tree_view->priv->rubber_band_modify = TRUE; ++ if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK) ++ tree_view->priv->rubber_band_extend = TRUE; ++ } ++ } ++ + /* select */ + node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED); + pre_val = tree_view->priv->vadjustment->value; +@@ -2782,7 +3096,106 @@ + if (focus_cell) + gtk_tree_view_column_focus_cell (column, focus_cell); + +- if (event->state & GTK_MODIFY_SELECTION_MOD_MASK) ++ /* The most reliable way is to use another row reference, ++ * instead of trying to get it done with the intricate ++ * logic below. ++ */ ++ gtk_tree_row_reference_free (tree_view->priv->queued_tapped_row); ++ tree_view->priv->queued_tapped_row = ++ gtk_tree_row_reference_new (tree_view->priv->model, path); ++ ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_NORMAL) ++ { ++ /* This row should be activated on button-release */ ++ gtk_tree_row_reference_free (tree_view->priv->queued_activate_row); ++ tree_view->priv->queued_activate_row = gtk_tree_row_reference_new (tree_view->priv->model, path); ++ ++ /* Mark the node as selected to create a highlight effect */ ++ tree_view->priv->highlighted_tree = tree; ++ tree_view->priv->highlighted_node = node; ++ gtk_tree_view_queue_draw_path (tree_view, path, NULL); ++ } ++ else if (tree_view->priv->hildon_mode == HILDON_DIABLO ++ && node_selected ++ && !column_handled_click ++ && gtk_tree_row_reference_valid (tree_view->priv->cursor)) ++ { ++ GtkTreePath *cursor_path; ++ ++ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); ++ if (!gtk_tree_path_compare (cursor_path, path)) ++ { ++ gtk_tree_row_reference_free (tree_view->priv->queued_activate_row); ++ tree_view->priv->queued_activate_row = gtk_tree_row_reference_new (tree_view->priv->model, path); ++ } ++ ++ gtk_tree_path_free (cursor_path); ++ } ++ ++ if (node_is_selectable ++ && tree_view->priv->hildon_mode == HILDON_DIABLO ++ && !column_handled_click ++ && !tree_view->priv->queued_activate_row ++ && tree_view->priv->rubber_band_status == RUBBER_BAND_OFF ++ && gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE) ++ { ++ GtkTreePath *old_cursor_path = NULL; ++ ++ /* We do not know at this stage if a user is going to do ++ * a DnD or tap and hold operation, so avoid clearing ++ * the current selection. ++ */ ++ if (tree_view->priv->queued_select_row) ++ gtk_tree_row_reference_free (tree_view->priv->queued_select_row); ++ tree_view->priv->queued_select_row = NULL; ++ ++ /* Do move the focus */ ++ if (tree_view->priv->cursor) ++ { ++ old_cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); ++ gtk_tree_row_reference_free (tree_view->priv->cursor); ++ } ++ ++ tree_view->priv->cursor = gtk_tree_row_reference_new (tree_view->priv->model, path); ++ ++ if (old_cursor_path) ++ { ++ gtk_tree_view_queue_draw_path (tree_view, ++ old_cursor_path, NULL); ++ gtk_tree_path_free (old_cursor_path); ++ } ++ ++ tree_view->priv->queued_ctrl_pressed = tree_view->priv->modify_selection_pressed; ++ tree_view->priv->queued_shift_pressed = tree_view->priv->extend_selection_pressed; ++ tree_view->priv->queued_select_row = ++ gtk_tree_row_reference_new (tree_view->priv->model, path); ++ ++ gtk_tree_view_queue_draw_path (tree_view, path, NULL); ++ } ++ else if (node_is_selectable ++ && tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT ++ && !column_handled_click ++ && !tree_view->priv->queued_activate_row) ++ { ++ /* In new-style we do not want to set cursor, ++ * instead we highlight the node. ++ */ ++ if (tree_view->priv->queued_select_row) ++ gtk_tree_row_reference_free (tree_view->priv->queued_select_row); ++ tree_view->priv->queued_select_row = NULL; ++ ++ tree_view->priv->highlighted_node = node; ++ tree_view->priv->highlighted_tree = tree; ++ ++ tree_view->priv->queued_select_row = ++ gtk_tree_row_reference_new (tree_view->priv->model, path); ++ ++ gtk_tree_view_queue_draw_path (tree_view, path, NULL); ++ } ++ /* Else, set the cursor as usual */ ++ else if (event->state & GTK_MODIFY_SELECTION_MOD_MASK) + { + gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE); + gtk_tree_view_real_toggle_cursor_row (tree_view); +@@ -2794,7 +3207,10 @@ + } + else + { +- gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE); ++ if (tree_view->priv->queued_activate_row) ++ gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE); ++ else ++ gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE); + } + + tree_view->priv->modify_selection_pressed = FALSE; +@@ -2811,74 +3227,24 @@ + cell_area.y += dval; + background_area.y += dval; + +- /* Save press to possibly begin a drag +- */ +- if (!column_handled_click && +- !tree_view->priv->in_grab && +- tree_view->priv->pressed_button < 0) +- { +- tree_view->priv->pressed_button = event->button; +- tree_view->priv->press_start_x = event->x; +- tree_view->priv->press_start_y = event->y; +- +- if (tree_view->priv->rubber_banding_enable +- && !node_selected +- && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE) ++ if (event->button == 1) ++ { ++ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT)) + { +- tree_view->priv->press_start_y += tree_view->priv->dy; +- tree_view->priv->rubber_band_x = event->x; +- tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy; +- tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START; +- +- if ((event->state & GTK_MODIFY_SELECTION_MOD_MASK) == GTK_MODIFY_SELECTION_MOD_MASK) +- tree_view->priv->rubber_band_modify = TRUE; +- if ((event->state & GTK_EXTEND_SELECTION_MOD_MASK) == GTK_EXTEND_SELECTION_MOD_MASK) +- tree_view->priv->rubber_band_extend = TRUE; ++ /* The behavior is as follows: ++ * - For a tap on a collapsed node: always expand (and the ++ * cursor moves to it. ++ * - For a tap on an expxanded node: collapse if and only ++ * if the node is currently the cursor node. ++ */ ++ if (!node->children ++ || (node_selected && node->children)) ++ { ++ gtk_tree_row_reference_free (tree_view->priv->queued_expand_row); ++ tree_view->priv->queued_expand_row = ++ gtk_tree_row_reference_new (tree_view->priv->model, path); ++ } + } +- } +- +- /* Test if a double click happened on the same row. */ +- if (event->button == 1 && event->type == GDK_BUTTON_PRESS) +- { +- int double_click_time, double_click_distance; +- +- g_object_get (gtk_settings_get_default (), +- "gtk-double-click-time", &double_click_time, +- "gtk-double-click-distance", &double_click_distance, +- NULL); +- +- /* Same conditions as _gdk_event_button_generate */ +- if (tree_view->priv->last_button_x != -1 && +- (event->time < tree_view->priv->last_button_time + double_click_time) && +- (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) && +- (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance)) +- { +- /* We do no longer compare paths of this row and the +- * row clicked previously. We use the double click +- * distance to decide whether this is a valid click, +- * allowing the mouse to slightly move over another row. +- */ +- row_double_click = TRUE; +- +- tree_view->priv->last_button_time = 0; +- tree_view->priv->last_button_x = -1; +- tree_view->priv->last_button_y = -1; +- } +- else +- { +- tree_view->priv->last_button_time = event->time; +- tree_view->priv->last_button_x = event->x; +- tree_view->priv->last_button_y = event->y; +- } +- } +- +- if (row_double_click) +- { +- gtk_grab_remove (widget); +- gtk_tree_view_row_activated (tree_view, path, column); +- +- if (tree_view->priv->pressed_button == event->button) +- tree_view->priv->pressed_button = -1; + } + + gtk_tree_path_free (path); +@@ -3039,6 +3405,9 @@ + GdkEventButton *event) + { + GtkTreeView *tree_view = GTK_TREE_VIEW (widget); ++ gint new_y; ++ GtkRBTree *tree; ++ GtkRBNode *node; + + if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG)) + return gtk_tree_view_button_release_drag_column (widget, event); +@@ -3052,6 +3421,171 @@ + if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE)) + return gtk_tree_view_button_release_column_resize (widget, event); + ++ if (tree_view->priv->tree) ++ { ++ /* Get the node where the mouse was released */ ++ new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, event->y); ++ if (new_y < 0) ++ new_y = 0; ++ _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node); ++ } ++ else ++ { ++ /* We just set tree and node to NULL otherwise. We still want ++ * to run through below's logic to free row references where needed. ++ */ ++ tree = NULL; ++ node = NULL; ++ } ++ ++ if (gtk_tree_row_reference_valid (tree_view->priv->queued_select_row)) ++ { ++ GtkTreePath *path; ++ GtkRBTree *select_tree; ++ GtkRBNode *select_node; ++ ++ path = gtk_tree_row_reference_get_path (tree_view->priv->queued_select_row); ++ _gtk_tree_view_find_node (tree_view, path, ++ &select_tree, &select_node); ++ ++ if (tree == select_tree && node == select_node) ++ { ++ if (tree_view->priv->queued_ctrl_pressed) ++ { ++ gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE); ++ gtk_tree_view_real_toggle_cursor_row (tree_view); ++ GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS); ++ } ++ else if (tree_view->priv->queued_shift_pressed) ++ { ++ gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE); ++ gtk_tree_view_real_select_cursor_row (tree_view, FALSE); ++ GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS); ++ } ++ else ++ gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE); ++ } ++ ++ free_queued_select_row (tree_view); ++ gtk_tree_path_free (path); ++ tree_view->priv->queued_ctrl_pressed = FALSE; ++ tree_view->priv->queued_shift_pressed = FALSE; ++ } ++ ++ if (gtk_tree_row_reference_valid (tree_view->priv->queued_activate_row)) ++ { ++ GtkTreePath *path; ++ GtkRBTree *activate_tree; ++ GtkRBNode *activate_node; ++ ++ path = gtk_tree_row_reference_get_path (tree_view->priv->queued_activate_row); ++ ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_NORMAL) ++ { ++ if (tree_view->priv->highlighted_node) ++ { ++ _gtk_tree_view_queue_draw_node (tree_view, ++ tree_view->priv->highlighted_tree, ++ tree_view->priv->highlighted_node, ++ NULL); ++ ++ tree_view->priv->highlighted_tree = NULL; ++ tree_view->priv->highlighted_node = NULL; ++ } ++ } ++ ++ _gtk_tree_view_find_node (tree_view, path, ++ &activate_tree, &activate_node); ++ ++ /* Only emit activated if the mouse was released from the ++ * same row where the mouse was pressed. ++ */ ++ if (tree == activate_tree && node == activate_node) ++ { ++ gtk_tree_view_row_activated (tree_view, path, ++ tree_view->priv->focus_column); ++ } ++ ++ gtk_tree_path_free (path); ++ ++ gtk_tree_row_reference_free (tree_view->priv->queued_activate_row); ++ tree_view->priv->queued_activate_row = NULL; ++ } ++ ++ if (gtk_tree_row_reference_valid (tree_view->priv->queued_expand_row)) ++ { ++ GtkTreePath *path; ++ GtkRBTree *expand_tree; ++ GtkRBNode *expand_node = NULL; ++ ++ path = gtk_tree_row_reference_get_path (tree_view->priv->queued_expand_row); ++ ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE) ++ { ++ /* We should not take the cursor into accont. We do check ++ * with the node where the mouse was released. ++ */ ++ _gtk_tree_view_find_node (tree_view, path, ++ &expand_tree, &expand_node); ++ ++ if (tree != expand_tree || node != expand_node) ++ expand_node = NULL; ++ } ++ else ++ { ++ GtkTreePath *cursor_path; ++ ++ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); ++ ++ if (!gtk_tree_path_compare (cursor_path, path)) ++ _gtk_tree_view_find_node (tree_view, path, ++ &expand_tree, &expand_node); ++ ++ gtk_tree_path_free (cursor_path); ++ } ++ ++ if (expand_node) ++ { ++ if (!expand_node->children) ++ gtk_tree_view_real_expand_row (tree_view, path, ++ expand_tree, expand_node, ++ FALSE, TRUE); ++ else ++ gtk_tree_view_real_collapse_row (tree_view, path, ++ expand_tree, expand_node, TRUE); ++ } ++ ++ gtk_tree_path_free (path); ++ ++ gtk_tree_row_reference_free (tree_view->priv->queued_expand_row); ++ tree_view->priv->queued_expand_row = NULL; ++ } ++ ++ /* The hildon-row-tapped signal is executed as the last, so that ++ * any action (selection change, activation, expansion/collapse) ++ * has already been processed. ++ */ ++ if (gtk_tree_row_reference_valid (tree_view->priv->queued_tapped_row)) ++ { ++ GtkTreePath *path; ++ GtkRBTree *tapped_tree; ++ GtkRBNode *tapped_node; ++ ++ path = gtk_tree_row_reference_get_path (tree_view->priv->queued_tapped_row); ++ _gtk_tree_view_find_node (tree_view, path, ++ &tapped_tree, &tapped_node); ++ ++ if (tree == tapped_tree && node == tapped_node) ++ g_signal_emit (tree_view, tree_view_signals[HILDON_ROW_TAPPED], ++ 0, path); ++ ++ gtk_tree_path_free (path); ++ ++ gtk_tree_row_reference_free (tree_view->priv->queued_tapped_row); ++ tree_view->priv->queued_tapped_row = NULL; ++ } ++ + if (tree_view->priv->button_pressed_node == NULL) + return FALSE; + +@@ -3331,6 +3865,22 @@ + } + + static void ++ensure_unhighlighted (GtkTreeView *tree_view) ++{ ++ /* Unconditionally unhighlight */ ++ if (tree_view->priv->highlighted_node) ++ { ++ _gtk_tree_view_queue_draw_node (tree_view, ++ tree_view->priv->highlighted_tree, ++ tree_view->priv->highlighted_node, ++ NULL); ++ ++ tree_view->priv->highlighted_tree = NULL; ++ tree_view->priv->highlighted_node = NULL; ++ } ++} ++ ++static void + update_prelight (GtkTreeView *tree_view, + gint x, + gint y) +@@ -3780,13 +4330,6 @@ + + gtk_tree_path_free (tmp_path); + +- /* ... and the cursor to the end path */ +- tmp_path = _gtk_tree_view_find_path (tree_view, +- tree_view->priv->rubber_band_end_tree, +- tree_view->priv->rubber_band_end_node); +- gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, FALSE, FALSE); +- gtk_tree_path_free (tmp_path); +- + _gtk_tree_selection_emit_changed (tree_view->priv->selection); + } + +@@ -3868,6 +4411,8 @@ + GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED); + } + ++ add_scroll_timeout (tree_view); ++ + _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL); + + node_not_selectable: +@@ -3903,6 +4448,7 @@ + { + GtkRBTree *start_tree, *end_tree; + GtkRBNode *start_node, *end_node; ++ GtkTreePath *path; + + _gtk_rbtree_find_offset (tree_view->priv->tree, MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &start_tree, &start_node); + _gtk_rbtree_find_offset (tree_view->priv->tree, MAX (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &end_tree, &end_node); +@@ -4001,6 +4547,17 @@ + + tree_view->priv->rubber_band_end_tree = end_tree; + tree_view->priv->rubber_band_end_node = end_node; ++ ++ /* In maemo the cursor needs to follow the stylus */ ++ if (gtk_tree_view_get_path_at_pos (tree_view, ++ tree_view->priv->rubber_band_x, ++ RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, tree_view->priv->rubber_band_y), ++ &path, ++ NULL, NULL, NULL)) ++ { ++ gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE); ++ gtk_tree_path_free (path); ++ } + } + + static void +@@ -4009,8 +4566,6 @@ + gint x, y; + GdkRectangle old_area; + GdkRectangle new_area; +- GdkRectangle common; +- GdkRegion *invalid_region; + + old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x); + old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy; +@@ -4027,30 +4582,6 @@ + new_area.width = ABS (x - tree_view->priv->press_start_x) + 1; + new_area.height = ABS (y - tree_view->priv->press_start_y) + 1; + +- invalid_region = gdk_region_rectangle (&old_area); +- gdk_region_union_with_rect (invalid_region, &new_area); +- +- gdk_rectangle_intersect (&old_area, &new_area, &common); +- if (common.width > 2 && common.height > 2) +- { +- GdkRegion *common_region; +- +- /* make sure the border is invalidated */ +- common.x += 1; +- common.y += 1; +- common.width -= 2; +- common.height -= 2; +- +- common_region = gdk_region_rectangle (&common); +- +- gdk_region_subtract (invalid_region, common_region); +- gdk_region_destroy (common_region); +- } +- +- gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE); +- +- gdk_region_destroy (invalid_region); +- + tree_view->priv->rubber_band_x = x; + tree_view->priv->rubber_band_y = y; + +@@ -4115,6 +4646,20 @@ + + if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START) + { ++ if (tree_view->priv->hildon_mode == HILDON_DIABLO ++ && gtk_tree_row_reference_valid (tree_view->priv->queued_select_row)) ++ { ++ GtkTreePath *path; ++ ++ /* We now know we won't rubber band -- select the row */ ++ path = gtk_tree_row_reference_get_path (tree_view->priv->queued_select_row); ++ gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE); ++ ++ gtk_tree_path_free (path); ++ } ++ ++ free_queued_actions (tree_view); ++ + gtk_grab_add (GTK_WIDGET (tree_view)); + gtk_tree_view_update_rubber_band (tree_view); + +@@ -4127,8 +4672,27 @@ + add_scroll_timeout (tree_view); + } + ++ /* If the drag-threshold has been passed, the row should ++ * not be activated or selected and the highlight removed. ++ */ ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && gtk_drag_check_threshold (widget, ++ tree_view->priv->press_start_x, ++ tree_view->priv->press_start_y, ++ event->x, event->y)) ++ { ++ if (tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_NORMAL) ++ free_queued_activate_row (tree_view); ++ else if (tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT) ++ free_queued_select_row (tree_view); ++ ++ gtk_tree_row_reference_free (tree_view->priv->queued_tapped_row); ++ tree_view->priv->queued_tapped_row = NULL; ++ } ++ + /* only check for an initiated drag when a button is pressed */ + if (tree_view->priv->pressed_button >= 0 ++ && tree_view->priv->hildon_mode == HILDON_DIABLO + && !tree_view->priv->rubber_band_status) + gtk_tree_view_maybe_begin_dragging_row (tree_view, event); + +@@ -4310,6 +4874,46 @@ + } + } + ++static void ++gtk_tree_view_draw_row_header (GtkTreeView *tree_view, ++ GtkTreeIter *iter, ++ GdkEventExpose *event, ++ GdkRectangle *cell_area) ++{ ++ gchar *label = NULL; ++ int width, height; ++ gboolean is_header; ++ GtkWidget *widget = GTK_WIDGET (tree_view); ++ ++ g_return_if_fail (tree_view->priv->row_header_func != NULL); ++ ++ is_header = (* tree_view->priv->row_header_func) (tree_view->priv->model, ++ iter, ++ &label, ++ tree_view->priv->row_header_data); ++ ++ g_return_if_fail (is_header == TRUE); ++ g_return_if_fail (tree_view->priv->row_header_layout != NULL); ++ ++ pango_layout_set_text (tree_view->priv->row_header_layout, ++ label, strlen (label)); ++ pango_layout_get_pixel_size (tree_view->priv->row_header_layout, ++ &width, &height); ++ ++ gtk_paint_layout (widget->style, ++ event->window, ++ widget->state, ++ TRUE, ++ &event->area, ++ widget, ++ "treeview-group-header", ++ cell_area->x + (cell_area->width - width) / 2, ++ cell_area->y + cell_area->height - height, ++ tree_view->priv->row_header_layout); ++ ++ g_free (label); ++} ++ + /* Warning: Very scary function. + * Modify at your own risk + * +@@ -4356,6 +4960,8 @@ + gboolean got_pointer = FALSE; + gboolean row_ending_details; + gboolean draw_vgrid_lines, draw_hgrid_lines; ++ gint expose_start; ++ gboolean render_checkboxes = FALSE; + + rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL); + +@@ -4379,11 +4985,27 @@ + + validate_visible_area (tree_view); + +- new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, event->area.y); ++ if (G_UNLIKELY (tree_view->priv->rows_offset != 0) ++ && tree_view->priv->dy <= tree_view->priv->rows_offset ++ && event->area.y <= tree_view->priv->rows_offset - tree_view->priv->dy) ++ { ++ /* As long as a part of the button window is visible ... */ ++ expose_start = tree_view->priv->rows_offset - tree_view->priv->dy; ++ y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, ++ tree_view->priv->rows_offset, ++ &tree, &node); ++ } ++ else ++ { ++ new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, event->area.y); ++ ++ if (new_y < 0) ++ new_y = 0; ++ ++ expose_start = event->area.y; ++ y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node); ++ } + +- if (new_y < 0) +- new_y = 0; +- y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node); + bin_window_width = gdk_window_get_width (tree_view->priv->bin_window); + bin_window_height = gdk_window_get_height (tree_view->priv->bin_window); + +@@ -4395,7 +5017,7 @@ + GTK_SHADOW_NONE, + &event->area, + widget, +- "cell_even", ++ "cell_blank", + 0, tree_view->priv->height, + bin_window_width, + bin_window_height - tree_view->priv->height); +@@ -4449,6 +5071,13 @@ + n_visible_columns ++; + } + ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT ++ && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE) ++ { ++ render_checkboxes = TRUE; ++ } ++ + /* Find the last column */ + for (last_column = g_list_last (tree_view->priv->columns); + last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible); +@@ -4472,8 +5101,9 @@ + gboolean is_separator = FALSE; + gboolean is_first = FALSE; + gboolean is_last = FALSE; ++ gboolean is_header = FALSE; + +- is_separator = row_is_separator (tree_view, &iter, NULL); ++ is_separator = row_is_separator (tree_view, &iter, &is_header, NULL); + + max_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)); + +@@ -4481,7 +5111,7 @@ + highlight_x = 0; /* should match x coord of first cell */ + expander_cell_width = 0; + +- background_area.y = y_offset + event->area.y; ++ background_area.y = y_offset + expose_start; + background_area.height = max_height; + + flags = 0; +@@ -4489,7 +5119,8 @@ + if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT)) + flags |= GTK_CELL_RENDERER_PRELIT; + +- if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED)) ++ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED) ++ || node == tree_view->priv->highlighted_node) + flags |= GTK_CELL_RENDERER_SELECTED; + + parity = _gtk_rbtree_node_find_parity (tree, node); +@@ -4503,12 +5134,13 @@ + list = (rtl ? list->prev : list->next)) + { + GtkTreeViewColumn *column = list->data; +- gtk_tree_view_column_cell_set_cell_data (column, +- tree_view->priv->model, +- &iter, +- GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT), +- node->children?TRUE:FALSE); +- } ++ gtk_tree_view_column_cell_set_cell_data_with_hint (column, ++ tree_view->priv->model, ++ &iter, ++ GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT), ++ node->children?TRUE:FALSE, ++ GTK_TREE_CELL_DATA_HINT_KEY_FOCUS); ++ } + + has_special_cell = gtk_tree_view_has_special_cell (tree_view); + +@@ -4543,7 +5175,11 @@ + background_area.x = cell_offset; + background_area.width = column->width; + +- cell_area = background_area; ++ /* Nasty hack to get background handling for free */ ++ if (render_checkboxes && column == last_column->data) ++ background_area.width += HILDON_TICK_MARK_SIZE; ++ ++ cell_area = background_area; + cell_area.y += vertical_separator / 2; + cell_area.x += horizontal_separator / 2; + cell_area.height -= vertical_separator; +@@ -4682,6 +5318,93 @@ + background_area.height); + } + ++ /* Nasty hack to get background handling for free */ ++ if (render_checkboxes && column == last_column->data) ++ { ++ background_area.width -= HILDON_TICK_MARK_SIZE; ++ cell_area.width -= HILDON_TICK_MARK_SIZE; ++ ++ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED)) ++ gdk_draw_pixbuf (event->window, ++ NULL, ++ tree_view->priv->tickmark_icon, ++ 0, 0, ++ background_area.x + background_area.width, ++ background_area.y + (background_area.height - HILDON_TICK_MARK_SIZE) / 2, ++ HILDON_TICK_MARK_SIZE, ++ HILDON_TICK_MARK_SIZE, ++ GDK_RGB_DITHER_MAX, ++ 0, 0); ++ } ++ ++ if (node == drag_highlight) ++ { ++ /* Draw indicator for the drop ++ */ ++ gint highlight_y = -1; ++ GtkRBTree *tree = NULL; ++ GtkRBNode *node = NULL; ++ gint width; ++ ++ switch (tree_view->priv->drag_dest_pos) ++ { ++ case GTK_TREE_VIEW_DROP_BEFORE: ++ highlight_y = background_area.y - 1; ++ if (highlight_y < 0) ++ highlight_y = 0; ++ break; ++ ++ case GTK_TREE_VIEW_DROP_AFTER: ++ highlight_y = background_area.y + background_area.height - 1; ++ break; ++ ++ case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: ++ case GTK_TREE_VIEW_DROP_INTO_OR_AFTER: ++ _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node); ++ ++ if (tree == NULL) ++ break; ++ gdk_drawable_get_size (tree_view->priv->bin_window, ++ &width, NULL); ++ ++ if (row_ending_details) ++ gtk_paint_focus (widget->style, ++ tree_view->priv->bin_window, ++ gtk_widget_get_state (widget), ++ &event->area, ++ widget, ++ (is_first ++ ? (is_last ? "treeview-drop-indicator" : "treeview-drop-indicator-left" ) ++ : (is_last ? "treeview-drop-indicator-right" : "tree-view-drop-indicator-middle" )), ++ 0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node) ++ - focus_line_width / 2, ++ width, ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)) ++ - focus_line_width + 1); ++ else ++ gtk_paint_focus (widget->style, ++ tree_view->priv->bin_window, ++ gtk_widget_get_state (widget), ++ &event->area, ++ widget, ++ "treeview-drop-indicator", ++ 0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node) ++ - focus_line_width / 2, ++ width, ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)) ++ - focus_line_width + 1); ++ break; ++ } ++ ++ if (highlight_y >= 0) ++ { ++ gdk_draw_line (event->window, ++ widget->style->fg_gc[gtk_widget_get_state (widget)], ++ rtl ? highlight_x + expander_cell_width : highlight_x, ++ highlight_y, ++ rtl ? 0 : bin_window_width, ++ highlight_y); ++ } ++ } ++ + if (gtk_tree_view_is_expander_column (tree_view, column)) + { + if (!rtl) +@@ -4702,7 +5425,14 @@ + highlight_x = cell_area.x; + expander_cell_width = cell_area.width; + +- if (is_separator) ++ if (is_header) ++ { ++ gtk_tree_view_draw_row_header (tree_view, ++ &iter, ++ event, ++ &cell_area); ++ } ++ else if (is_separator) + gtk_paint_hline (widget->style, + event->window, + state, +@@ -4737,7 +5467,14 @@ + } + else + { +- if (is_separator) ++ if (is_header) ++ { ++ gtk_tree_view_draw_row_header (tree_view, ++ &iter, ++ event, ++ &cell_area); ++ } ++ else if (is_separator) + gtk_paint_hline (widget->style, + event->window, + state, +@@ -4862,73 +5599,6 @@ + cell_offset += column->width; + } + +- if (node == drag_highlight) +- { +- /* Draw indicator for the drop +- */ +- gint highlight_y = -1; +- GtkRBTree *tree = NULL; +- GtkRBNode *node = NULL; +- gint width; +- +- switch (tree_view->priv->drag_dest_pos) +- { +- case GTK_TREE_VIEW_DROP_BEFORE: +- highlight_y = background_area.y - 1; +- if (highlight_y < 0) +- highlight_y = 0; +- break; +- +- case GTK_TREE_VIEW_DROP_AFTER: +- highlight_y = background_area.y + background_area.height - 1; +- break; +- +- case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: +- case GTK_TREE_VIEW_DROP_INTO_OR_AFTER: +- _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node); +- +- if (tree == NULL) +- break; +- width = gdk_window_get_width (tree_view->priv->bin_window); +- +- if (row_ending_details) +- gtk_paint_focus (widget->style, +- tree_view->priv->bin_window, +- gtk_widget_get_state (widget), +- &event->area, +- widget, +- (is_first +- ? (is_last ? "treeview-drop-indicator" : "treeview-drop-indicator-left" ) +- : (is_last ? "treeview-drop-indicator-right" : "tree-view-drop-indicator-middle" )), +- 0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node) +- - focus_line_width / 2, +- width, ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)) +- - focus_line_width + 1); +- else +- gtk_paint_focus (widget->style, +- tree_view->priv->bin_window, +- gtk_widget_get_state (widget), +- &event->area, +- widget, +- "treeview-drop-indicator", +- 0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node) +- - focus_line_width / 2, +- width, ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)) +- - focus_line_width + 1); +- break; +- } +- +- if (highlight_y >= 0) +- { +- gtk_tree_view_draw_line (tree_view, event->window, +- GTK_TREE_VIEW_FOREGROUND_LINE, +- rtl ? highlight_x + expander_cell_width : highlight_x, +- highlight_y, +- rtl ? 0 : bin_window_width, +- highlight_y); +- } +- } +- + /* draw the big row-spanning focus rectangle, if needed */ + if (!has_special_cell && node == cursor && + GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) && +@@ -5042,21 +5712,6 @@ + done: + gtk_tree_view_draw_grid_lines (tree_view, event, n_visible_columns); + +- if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE) +- { +- GdkRectangle *rectangles; +- gint n_rectangles; +- +- gdk_region_get_rectangles (event->region, +- &rectangles, +- &n_rectangles); +- +- while (n_rectangles--) +- gtk_tree_view_paint_rubber_band (tree_view, &rectangles[n_rectangles]); +- +- g_free (rectangles); +- } +- + if (cursor_path) + gtk_tree_path_free (cursor_path); + +@@ -5504,6 +6159,15 @@ + * the typeahead find capabilities. */ + if (gtk_widget_has_focus (GTK_WIDGET (tree_view)) + && tree_view->priv->enable_search ++ /* These are usually handled via keybindings, but these do not ++ * function in Fremantle mode. Therefore we need to explicitly ++ * check for these there. ++ */ ++ && event->keyval != GDK_ISO_Enter ++ && event->keyval != GDK_KP_Enter ++ && event->keyval != GDK_Return ++ && event->keyval != GDK_space ++ && event->keyval != GDK_KP_Space + && !tree_view->priv->search_custom_entry_set) + { + GdkEvent *new_event; +@@ -5730,13 +6394,15 @@ + gint grid_line_width; + gboolean wide_separators; + gint separator_height; ++ gint row_height; ++ gboolean is_header = FALSE; + + /* double check the row needs validating */ + if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) && + ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID)) + return FALSE; + +- is_separator = row_is_separator (tree_view, iter, NULL); ++ is_separator = row_is_separator (tree_view, iter, &is_header, NULL); + + gtk_widget_style_get (GTK_WIDGET (tree_view), + "focus-padding", &focus_pad, +@@ -5746,6 +6412,7 @@ + "grid-line-width", &grid_line_width, + "wide-separators", &wide_separators, + "separator-height", &separator_height, ++ "row-height", &row_height, + NULL); + + draw_vgrid_lines = +@@ -5793,10 +6460,12 @@ + } + else + { +- if (wide_separators) +- height = separator_height + 2 * focus_pad; +- else +- height = 2 + 2 * focus_pad; ++ if (is_header) ++ { ++ height = HILDON_ROW_HEADER_HEIGHT; ++ } ++ else ++ height = separator_height + 2 * focus_pad; + } + + if (gtk_tree_view_is_expander_column (tree_view, column)) +@@ -5817,6 +6486,14 @@ + tmp_width += grid_line_width; + } + ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT ++ && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE) ++ { ++ tmp_width += HILDON_TICK_MARK_SIZE; ++ height = MAX (height, HILDON_TICK_MARK_SIZE); ++ } ++ + if (tmp_width > column->requested_width) + { + retval = TRUE; +@@ -5827,6 +6504,9 @@ + if (draw_hgrid_lines) + height += grid_line_width; + ++ if (row_height != -1 && !is_separator && !is_header) ++ height = row_height; ++ + if (height != GTK_RBNODE_GET_HEIGHT (node)) + { + retval = TRUE; +@@ -6180,33 +6860,166 @@ + { + GtkRequisition requisition; + +- /* We temporarily guess a size, under the assumption that it will be the +- * same when we get our next size_allocate. If we don't do this, we'll be +- * in an inconsistent state if we call top_row_to_dy. */ ++ /* We temporarily guess a size, under the assumption that it will be the ++ * same when we get our next size_allocate. If we don't do this, we'll be ++ * in an inconsistent state if we call top_row_to_dy. */ ++ ++ gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition); ++ tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width); ++ tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height); ++ gtk_adjustment_changed (tree_view->priv->hadjustment); ++ gtk_adjustment_changed (tree_view->priv->vadjustment); ++ gtk_widget_queue_resize (GTK_WIDGET (tree_view)); ++ } ++ ++ if (tree_view->priv->scroll_to_path) ++ { ++ gtk_tree_row_reference_free (tree_view->priv->scroll_to_path); ++ tree_view->priv->scroll_to_path = NULL; ++ } ++ ++ if (above_path) ++ gtk_tree_path_free (above_path); ++ ++ if (tree_view->priv->scroll_to_column) ++ { ++ tree_view->priv->scroll_to_column = NULL; ++ } ++ if (need_redraw) ++ gtk_widget_queue_draw (GTK_WIDGET (tree_view)); ++} ++ ++/* You can pass in focus_pad, separator_height to save ++ * calls to gtk_widget_style_get() (especially for ++ * gtk_tree_view_nodes_set_fixed_height). ++ */ ++static inline int ++determine_row_height (GtkTreeView *tree_view, ++ GtkTreeIter *iter, ++ int focus_pad, ++ int separator_height) ++{ ++ int height; ++ gboolean is_separator, is_header = FALSE; ++ ++ /* Determine the correct height for this node. This is ++ * analogous to what is found in validate_row(). ++ */ ++ is_separator = row_is_separator (tree_view, iter, &is_header, NULL); ++ ++ if (!is_separator) ++ height = tree_view->priv->fixed_height; ++ else if (is_header) ++ height = HILDON_ROW_HEADER_HEIGHT; ++ else ++ { ++ if (focus_pad == -1 || separator_height == -1) ++ gtk_widget_style_get (GTK_WIDGET (tree_view), ++ "focus-padding", &focus_pad, ++ "separator-height", &separator_height, ++ NULL); ++ ++ height = separator_height + 2 * focus_pad; ++ } ++ ++ return height; ++} ++ ++/* This function is basically an extended and non-recursive version of ++ * _gtk_rbtree_set_fixed_height() which also keeps track of the current ++ * iter. We can then pass this iter in to the row separator and ++ * row header funcs. ++ */ ++static void ++gtk_tree_view_nodes_set_fixed_height (GtkTreeView *tree_view) ++{ ++ int focus_pad; ++ int separator_height; ++ GtkRBTree *tree; ++ GtkRBNode *node; ++ GtkTreeIter iter; ++ ++ tree = tree_view->priv->tree; ++ ++ if (tree == NULL) ++ return; ++ ++ node = tree->root; ++ g_assert (node); ++ ++ /* Rewind tree, we start at the first node */ ++ while (node->left != tree->nil) ++ node = node->left; ++ ++ gtk_tree_model_get_iter_first (tree_view->priv->model, &iter); ++ ++ gtk_widget_style_get (GTK_WIDGET (tree_view), ++ "focus-padding", &focus_pad, ++ "separator-height", &separator_height, ++ NULL); ++ ++ /* This loop is equivalent to the one in bin_expose, but with ++ * the extra assertions removed. ++ */ ++ do ++ { ++ if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)) ++ { ++ int height; ++ ++ height = determine_row_height (tree_view, &iter, ++ focus_pad, separator_height); ++ ++ _gtk_rbtree_node_set_height (tree, node, height); ++ _gtk_rbtree_node_mark_valid (tree, node); ++ } ++ ++ if (node->children) ++ { ++ GtkTreeIter parent = iter; ++ ++ tree = node->children; ++ node = tree->root; ++ ++ g_assert (node != tree->nil); + +- gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition); +- tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width); +- tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height); +- gtk_adjustment_changed (tree_view->priv->hadjustment); +- gtk_adjustment_changed (tree_view->priv->vadjustment); +- gtk_widget_queue_resize (GTK_WIDGET (tree_view)); +- } ++ while (node->left != tree->nil) ++ node = node->left; + +- if (tree_view->priv->scroll_to_path) +- { +- gtk_tree_row_reference_free (tree_view->priv->scroll_to_path); +- tree_view->priv->scroll_to_path = NULL; +- } ++ gtk_tree_model_iter_children (tree_view->priv->model, ++ &iter, &parent); ++ } ++ else ++ { ++ gboolean done = FALSE; + +- if (above_path) +- gtk_tree_path_free (above_path); ++ do ++ { ++ node = _gtk_rbtree_next (tree, node); ++ if (node != NULL) ++ { ++ gtk_tree_model_iter_next (tree_view->priv->model, &iter); ++ done = TRUE; ++ } ++ else ++ { ++ GtkTreeIter parent_iter = iter; + +- if (tree_view->priv->scroll_to_column) +- { +- tree_view->priv->scroll_to_column = NULL; ++ node = tree->parent_node; ++ tree = tree->parent_tree; ++ ++ if (!tree) ++ /* We are done */ ++ return; ++ ++ gtk_tree_model_iter_parent (tree_view->priv->model, ++ &iter, &parent_iter); ++ } ++ } ++ while (!done); ++ } + } +- if (need_redraw) +- gtk_widget_queue_draw (GTK_WIDGET (tree_view)); ++ while (TRUE); + } + + static void +@@ -6227,6 +7040,29 @@ + node = tree->root; + + path = _gtk_tree_view_find_path (tree_view, tree, node); ++ ++ /* Search for the first regular row */ ++ while (node) ++ { ++ gboolean is_header = FALSE, is_separator; ++ ++ is_separator = row_is_separator (tree_view, NULL, &is_header, path); ++ if (!is_separator && !is_header) ++ break; ++ ++ _gtk_rbtree_next_full (tree, node, &tree, &node); ++ ++ gtk_tree_path_free (path); ++ ++ if (node) ++ path = _gtk_tree_view_find_path (tree_view, tree, node); ++ else ++ path = NULL; ++ } ++ ++ if (!path) ++ return; ++ + gtk_tree_model_get_iter (tree_view->priv->model, &iter, path); + + validate_row (tree_view, tree, node, &iter, path); +@@ -6236,8 +7072,16 @@ + tree_view->priv->fixed_height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node)); + } + +- _gtk_rbtree_set_fixed_height (tree_view->priv->tree, +- tree_view->priv->fixed_height, TRUE); ++ /* If a separator or row header func has been set, we cannot ++ * uniformly set the same height on all rows. We fall back to ++ * a slower alternative. ++ */ ++ if (tree_view->priv->row_separator_func ++ || tree_view->priv->row_header_func) ++ gtk_tree_view_nodes_set_fixed_height (tree_view); ++ else ++ _gtk_rbtree_set_fixed_height (tree_view->priv->tree, ++ tree_view->priv->fixed_height, TRUE); + } + + /* Our strategy for finding nodes to validate is a little convoluted. We find +@@ -7206,6 +8050,9 @@ + + set_source_row (context, model, path); + ++ /* Clear pending actions on row */ ++ free_queued_actions (tree_view); ++ + out: + if (path) + gtk_tree_path_free (path); +@@ -7708,12 +8555,20 @@ + gtk_tree_view_has_special_cell (GtkTreeView *tree_view) + { + GList *list; ++ guint n_specials = 0; + + for (list = tree_view->priv->columns; list; list = list->next) + { + if (!((GtkTreeViewColumn *)list->data)->visible) + continue; +- if (_gtk_tree_view_column_count_special_cells (list->data)) ++ /* We return true if there is more than one special cell. Since ++ * we do not want to have the per-cell focus rectangles when there ++ * is only a single activatable cell, we return FALSE for ++ * n_specials == 1 ++ */ ++ n_specials += _gtk_tree_view_column_count_special_cells (list->data); ++ ++ if (n_specials > 1) + return TRUE; + } + +@@ -7813,148 +8668,11 @@ + GtkDirectionType dir, + gboolean clamp_column_visible) + { +- GtkWidget *focus_child; +- +- GList *last_column, *first_column; +- GList *tmp_list; +- gboolean rtl; +- +- if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE)) +- return FALSE; +- +- focus_child = GTK_CONTAINER (tree_view)->focus_child; +- +- first_column = tree_view->priv->columns; +- while (first_column) +- { +- if (gtk_widget_get_can_focus (GTK_TREE_VIEW_COLUMN (first_column->data)->button) && +- GTK_TREE_VIEW_COLUMN (first_column->data)->visible && +- (GTK_TREE_VIEW_COLUMN (first_column->data)->clickable || +- GTK_TREE_VIEW_COLUMN (first_column->data)->reorderable)) +- break; +- first_column = first_column->next; +- } +- +- /* No headers are visible, or are focusable. We can't focus in or out. +- */ +- if (first_column == NULL) +- return FALSE; +- +- last_column = g_list_last (tree_view->priv->columns); +- while (last_column) +- { +- if (gtk_widget_get_can_focus (GTK_TREE_VIEW_COLUMN (last_column->data)->button) && +- GTK_TREE_VIEW_COLUMN (last_column->data)->visible && +- (GTK_TREE_VIEW_COLUMN (last_column->data)->clickable || +- GTK_TREE_VIEW_COLUMN (last_column->data)->reorderable)) +- break; +- last_column = last_column->prev; +- } +- +- +- rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL); +- +- switch (dir) +- { +- case GTK_DIR_TAB_BACKWARD: +- case GTK_DIR_TAB_FORWARD: +- case GTK_DIR_UP: +- case GTK_DIR_DOWN: +- if (focus_child == NULL) +- { +- if (tree_view->priv->focus_column != NULL && +- gtk_widget_get_can_focus (tree_view->priv->focus_column->button)) +- focus_child = tree_view->priv->focus_column->button; +- else +- focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button; +- gtk_widget_grab_focus (focus_child); +- break; +- } +- return FALSE; +- +- case GTK_DIR_LEFT: +- case GTK_DIR_RIGHT: +- if (focus_child == NULL) +- { +- if (tree_view->priv->focus_column != NULL) +- focus_child = tree_view->priv->focus_column->button; +- else if (dir == GTK_DIR_LEFT) +- focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button; +- else +- focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button; +- gtk_widget_grab_focus (focus_child); +- break; +- } +- +- if (gtk_widget_child_focus (focus_child, dir)) +- { +- /* The focus moves inside the button. */ +- /* This is probably a great example of bad UI */ +- break; +- } +- +- /* We need to move the focus among the row of buttons. */ +- for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next) +- if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child) +- break; +- +- if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT)) +- || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))) +- { +- gtk_widget_error_bell (GTK_WIDGET (tree_view)); +- break; +- } +- +- while (tmp_list) +- { +- GtkTreeViewColumn *column; +- +- if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)) +- tmp_list = tmp_list->next; +- else +- tmp_list = tmp_list->prev; +- +- if (tmp_list == NULL) +- { +- g_warning ("Internal button not found"); +- break; +- } +- column = tmp_list->data; +- if (column->button && +- column->visible && +- gtk_widget_get_can_focus (column->button)) +- { +- focus_child = column->button; +- gtk_widget_grab_focus (column->button); +- break; +- } +- } +- break; +- default: +- g_assert_not_reached (); +- break; +- } +- +- /* if focus child is non-null, we assume it's been set to the current focus child ++ /* Skip headers when acquiring focus; behave the same as the headers ++ * are invisible. + */ +- if (focus_child) +- { +- for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next) +- if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child) +- { +- tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data); +- break; +- } +- +- if (clamp_column_visible) +- { +- gtk_tree_view_clamp_column_visible (tree_view, +- tree_view->priv->focus_column, +- FALSE); +- } +- } + +- return (focus_child != NULL); ++ return FALSE; + } + + /* This function returns in 'path' the first focusable path, if the given path +@@ -7978,7 +8696,9 @@ + if (!tree || !node) + return FALSE; + +- while (node && row_is_separator (tree_view, NULL, *path)) ++ while (node && ++ !_gtk_tree_selection_row_is_selectable (tree_view->priv->selection, ++ node, *path)) + { + if (search_forward) + _gtk_rbtree_next_full (tree, node, &tree, &node); +@@ -8097,6 +8817,31 @@ + tree_view->priv->fixed_height = -1; + _gtk_rbtree_mark_invalid (tree_view->priv->tree); + ++ /* Cache the hildon-mode because it is slow to call gtk_widget_style_get ++ * too much. */ ++ gtk_widget_style_get (GTK_WIDGET (tree_view), ++ "hildon-mode", &tree_view->priv->hildon_mode, ++ NULL); ++ ++ /* Reset the UI mode */ ++ hildon_tree_view_set_hildon_ui_mode (tree_view, ++ tree_view->priv->hildon_ui_mode); ++ ++ if (tree_view->priv->row_header_layout) ++ hildon_tree_view_setup_row_header_layout (tree_view); ++ ++ if (tree_view->priv->tickmark_icon) ++ g_object_unref (tree_view->priv->tickmark_icon); ++ ++ tree_view->priv->tickmark_icon = ++ gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), ++ "widgets_tickmark_list", ++ HILDON_TICK_MARK_SIZE, ++ 0, NULL); ++ ++ if (tree_view->priv->action_area_visible) ++ hildon_tree_view_set_action_area_height (tree_view); ++ + gtk_widget_queue_resize (widget); + } + +@@ -8354,10 +9099,39 @@ + if (tree == NULL) + goto done; + ++ /* Unselect the row if it just became insensitive */ ++ if (!_gtk_tree_selection_row_is_selectable (tree_view->priv->selection, ++ node, path) ++ && gtk_tree_row_reference_valid (tree_view->priv->cursor)) ++ { ++ GtkTreePath *cursor_path; ++ ++ cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); ++ if (! gtk_tree_path_compare (path, cursor_path)) ++ { ++ gtk_tree_row_reference_free (tree_view->priv->cursor); ++ tree_view->priv->cursor = NULL; ++ } ++ ++ gtk_tree_selection_unselect_path (tree_view->priv->selection, path); ++ ++ gtk_tree_path_free (cursor_path); ++ } ++ + if (tree_view->priv->fixed_height_mode + && tree_view->priv->fixed_height >= 0) + { +- _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height); ++ if (tree_view->priv->row_separator_func ++ || tree_view->priv->row_header_func) ++ { ++ int height; ++ ++ height = determine_row_height (tree_view, iter, -1, -1); ++ _gtk_rbtree_node_set_height (tree, node, height); ++ } ++ else ++ _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height); ++ + if (gtk_widget_get_realized (GTK_WIDGET (tree_view))) + gtk_tree_view_node_queue_redraw (tree_view, tree, node); + } +@@ -8407,7 +9181,13 @@ + + if (tree_view->priv->fixed_height_mode + && tree_view->priv->fixed_height >= 0) +- height = tree_view->priv->fixed_height; ++ { ++ if (tree_view->priv->row_separator_func ++ || tree_view->priv->row_header_func) ++ height = determine_row_height (tree_view, iter, -1, -1); ++ else ++ height = tree_view->priv->fixed_height; ++ } + else + height = 0; + +@@ -8420,7 +9200,13 @@ + gtk_tree_model_get_iter (model, iter, path); + + if (tree_view->priv->tree == NULL) +- tree_view->priv->tree = _gtk_rbtree_new (); ++ { ++ tree_view->priv->tree = _gtk_rbtree_new (); ++ ++ if (G_UNLIKELY (tree_view->priv->rows_offset != 0)) ++ _gtk_rbtree_set_base_offset (tree_view->priv->tree, ++ tree_view->priv->rows_offset); ++ } + + tmptree = tree = tree_view->priv->tree; + +@@ -8485,6 +9271,23 @@ + tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE); + } + ++ /* If this was the first node inserted in the tree, we want to ++ * select it. ++ */ ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT ++ && tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE ++ && gtk_tree_selection_count_selected_rows (tree_view->priv->selection) < 1) ++ { ++ GtkTreePath *tmppath; ++ ++ tmppath = gtk_tree_path_new_first (); ++ search_first_focusable_path (tree_view, &tmppath, ++ TRUE, NULL, NULL); ++ gtk_tree_selection_select_path (tree_view->priv->selection, tmppath); ++ gtk_tree_path_free (tmppath); ++ } ++ + done: + if (height > 0) + { +@@ -8631,6 +9434,8 @@ + + /* Ensure we don't have a dangling pointer to a dead node */ + ensure_unprelighted (tree_view); ++ free_queued_actions (tree_view); ++ ensure_unhighlighted (tree_view); + + /* Cancel editting if we've started */ + gtk_tree_view_stop_editing (tree_view, TRUE); +@@ -8638,6 +9443,12 @@ + /* If we have a node expanded/collapsed timeout, remove it */ + remove_expand_collapse_timeout (tree_view); + ++ /* Stop rubber banding as row deletion invalidates the start/end ++ * rbtree/nodes. Should consider updating the pointers instead. ++ */ ++ if (tree_view->priv->rubber_band_status) ++ gtk_tree_view_stop_rubber_band (tree_view); ++ + if (tree_view->priv->destroy_count_func) + { + gint child_count = 0; +@@ -8666,6 +9477,24 @@ + + install_scroll_sync_handler (tree_view); + ++ if (selection_changed ++ && tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT ++ && tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE ++ && gtk_tree_selection_count_selected_rows (tree_view->priv->selection) < 1) ++ { ++ GtkTreePath *tmppath; ++ ++ /* One item must be selected, now there is none. If iter_first ++ * does not exist, the view is empty. ++ */ ++ tmppath = gtk_tree_path_new_first (); ++ search_first_focusable_path (tree_view, &tmppath, ++ TRUE, NULL, NULL); ++ gtk_tree_selection_select_path (tree_view->priv->selection, tmppath); ++ gtk_tree_path_free (tmppath); ++ } ++ + gtk_widget_queue_resize (GTK_WIDGET (tree_view)); + + if (selection_changed) +@@ -8714,6 +9543,8 @@ + + /* we need to be unprelighted */ + ensure_unprelighted (tree_view); ++ free_queued_actions (tree_view); ++ ensure_unhighlighted (tree_view); + + /* clear the timeout */ + cancel_arrow_animation (tree_view); +@@ -9590,6 +10421,9 @@ + { + GtkTreePath *cursor_path; + ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE) ++ return; ++ + if ((tree_view->priv->tree == NULL) || + (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))) + return; +@@ -9628,8 +10462,11 @@ + + if (cursor_path) + { +- if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE) +- gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE); ++ if ((tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE) ++ && tree_view->priv->hildon_mode == HILDON_DIABLO) ++ { ++ gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE); ++ } + else + gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE); + } +@@ -9833,6 +10670,8 @@ + + if (y >= tree_view->priv->height) + y = tree_view->priv->height - 1; ++ else if (tree_view->priv->rows_offset != 0 && y < tree_view->priv->rows_offset) ++ y = tree_view->priv->rows_offset; + + tree_view->priv->cursor_offset = + _gtk_rbtree_find_offset (tree_view->priv->tree, y, +@@ -9942,11 +10781,12 @@ + if (column->visible == FALSE) + goto loop_end; + +- gtk_tree_view_column_cell_set_cell_data (column, +- tree_view->priv->model, +- &iter, +- GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT), +- cursor_node->children?TRUE:FALSE); ++ gtk_tree_view_column_cell_set_cell_data_with_hint (column, ++ tree_view->priv->model, ++ &iter, ++ GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT), ++ cursor_node->children?TRUE:FALSE, ++ GTK_TREE_CELL_DATA_HINT_KEY_FOCUS); + + if (rtl) + { +@@ -10007,6 +10847,12 @@ + + gtk_tree_view_get_cursor (tree_view, &old_path, NULL); + ++ /* Immediately return when there is no cursor. (Like all other ++ * cursor movement handlers -- should prolly go upstream). ++ */ ++ if (!old_path) ++ return; ++ + cursor_tree = tree_view->priv->tree; + cursor_node = cursor_tree->root; + +@@ -10115,6 +10961,54 @@ + return FALSE; + } + ++ if (start_editing) ++ { ++ GList *list; ++ gboolean rtl; ++ GtkTreeIter iter; ++ ++ /* In case we have only one activatable cell in the tree view, we have ++ * a special case. We will have to set the cell data on the cursor ++ * row in order to figure out. ++ */ ++ gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path); ++ rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL); ++ ++ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns)); ++ list; ++ list = (rtl ? list->prev : list->next)) ++ { ++ GtkTreeViewColumn *column = list->data; ++ gtk_tree_view_column_cell_set_cell_data_with_hint (column, ++ tree_view->priv->model, ++ &iter, ++ GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT), ++ cursor_node->children?TRUE:FALSE, ++ GTK_TREE_CELL_DATA_HINT_KEY_FOCUS); ++ } ++ ++ if (!gtk_tree_view_has_special_cell (tree_view)) ++ { ++ /* We now set focus_column to the first column with an activatable ++ * cell that we can find. This is either none, or the one with ++ * the only activatable cell that is around. ++ */ ++ for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns)); ++ list; ++ list = (rtl ? list->prev : list->next)) ++ { ++ GtkTreeViewColumn *column = list->data; ++ ++ if (column->visible ++ && _gtk_tree_view_column_count_special_cells (column)) ++ { ++ tree_view->priv->focus_column = column; ++ break; ++ } ++ } ++ } ++ } ++ + if (!tree_view->priv->extend_selection_pressed && start_editing && + tree_view->priv->focus_column) + { +@@ -10235,18 +11129,40 @@ + if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node)) + return FALSE; + +- /* Don't handle the event if we aren't an expander */ +- if (!((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)) +- return FALSE; +- + if (!logical + && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL) + expand = !expand; + + if (expand) +- gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE); ++ { ++ gboolean expanded; ++ ++ expanded = gtk_tree_view_real_expand_row (tree_view, cursor_path, ++ tree, node, open_all, TRUE); ++ if (!expanded ++ && !gtk_widget_keynav_failed (GTK_WIDGET (tree_view), GTK_DIR_RIGHT)) ++ { ++ GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view)); ++ if (toplevel) ++ gtk_widget_child_focus (toplevel, GTK_DIR_TAB_FORWARD); ++ } ++ } + else +- gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE); ++ { ++ gboolean collapsed; ++ ++ collapsed = gtk_tree_view_real_collapse_row (tree_view, cursor_path, ++ tree, node, TRUE); ++ if (!collapsed ++ && !gtk_widget_keynav_failed (GTK_WIDGET (tree_view), GTK_DIR_LEFT)) ++ { ++ GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view)); ++ if (toplevel) ++ gtk_widget_child_focus (toplevel, GTK_DIR_TAB_BACKWARD); ++ ++ gtk_tree_view_real_select_cursor_parent (tree_view); ++ } ++ } + + gtk_tree_path_free (cursor_path); + +@@ -10361,6 +11277,7 @@ + } + + tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP); ++ gtk_window_set_is_temporary (GTK_WINDOW (tree_view->priv->search_window), TRUE); + gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen); + + if (GTK_WINDOW (toplevel)->group) +@@ -10792,6 +11709,11 @@ + gtk_tree_row_reference_free (tree_view->priv->scroll_to_path); + tree_view->priv->scroll_to_path = NULL; + ++ tree_view->priv->highlighted_tree = NULL; ++ tree_view->priv->highlighted_node = NULL; ++ ++ free_queued_actions (tree_view); ++ + tree_view->priv->scroll_to_column = NULL; + + g_object_unref (tree_view->priv->model); +@@ -10859,8 +11781,24 @@ + if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path)) + { + tree_view->priv->tree = _gtk_rbtree_new (); ++ ++ if (G_UNLIKELY (tree_view->priv->rows_offset != 0)) ++ _gtk_rbtree_set_base_offset (tree_view->priv->tree, ++ tree_view->priv->rows_offset); ++ + gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE); + } ++ ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT ++ && tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE) ++ { ++ /* Select the first item */ ++ search_first_focusable_path (tree_view, &path, ++ TRUE, NULL, NULL); ++ gtk_tree_selection_select_path (tree_view->priv->selection, path); ++ } ++ + gtk_tree_path_free (path); + + /* FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */ +@@ -12079,6 +13017,12 @@ + GtkTreeIter iter; + GtkTreeIter temp; + gboolean expand; ++ gint dy; ++ GtkTreeIter tmpiter; ++ GtkTreePath *tmppath; ++ GtkRBTree *tmptree; ++ GtkRBNode *tmpnode; ++ gint branch_height; + + if (animate) + g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)), +@@ -12147,12 +13091,54 @@ + gtk_tree_path_get_depth (path) + 1, + open_all); + +- remove_expand_collapse_timeout (tree_view); ++ remove_expand_collapse_timeout (tree_view); ++ ++ if (animate) ++ add_expand_collapse_timeout (tree_view, tree, node, TRUE); ++ ++ /* We do validate new nodes ourselves below, but we still need ++ * somebody to take care of the actual resizing. ++ */ ++ if (gtk_widget_get_mapped (GTK_WIDGET (tree_view))) ++ gtk_widget_queue_resize (GTK_WIDGET (tree_view)); ++ ++ install_presize_handler (tree_view); ++ ++ gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path); ++ _gtk_tree_view_find_node (tree_view, path, &tmptree, &tmpnode); ++ ++ validate_row (tree_view, tmptree, tmpnode, &tmpiter, path); ++ branch_height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (tmpnode)); ++ dy = _gtk_rbtree_node_find_offset (tmptree, tmpnode); ++ ++ tmppath = gtk_tree_path_copy (path); ++ gtk_tree_path_down (tmppath); ++ gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath); ++ ++ do ++ { ++ _gtk_tree_view_find_node (tree_view, tmppath, &tmptree, &tmpnode); ++ ++ validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath); ++ branch_height += ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (tmpnode)); ++ ++ gtk_tree_path_next (tmppath); ++ } ++ while (gtk_tree_model_iter_next (tree_view->priv->model, &tmpiter)); ++ ++ gtk_tree_path_prev (tmppath); + +- if (animate) +- add_expand_collapse_timeout (tree_view, tree, node, TRUE); ++ /* We scroll to the just expanded row if the expanding row and its children ++ * do not fit in the view. ++ * Otherwise, if the last child is not visible, we scroll to it to make ++ * sure all children are visible. ++ */ ++ if (branch_height > GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) ++ gtk_tree_view_scroll_to_cell (tree_view, path, NULL, TRUE, 0.0, 0.0); ++ else if (dy + branch_height > tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size) ++ gtk_tree_view_scroll_to_cell (tree_view, tmppath, NULL, TRUE, 1.0, 0.0); + +- install_presize_handler (tree_view); ++ gtk_tree_path_free (tmppath); + + g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path); + if (open_all && node->children) +@@ -12556,6 +13542,20 @@ + GtkRBTree *tree = NULL; + GtkRBNode *node = NULL; + ++ _gtk_tree_view_find_node (tree_view, path, &tree, &node); ++ ++ /* If we are in legacy or in (new-style) edit mode, row-insensitive ++ * can be emitted. ++ */ ++ if ((tree_view->priv->hildon_mode == HILDON_DIABLO ++ || tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT) ++ && !_gtk_tree_selection_row_is_selectable (tree_view->priv->selection, ++ node, path)) ++ { ++ g_signal_emit (tree_view, tree_view_signals[ROW_INSENSITIVE], 0, path); ++ return; ++ } ++ + if (gtk_tree_row_reference_valid (tree_view->priv->cursor)) + { + GtkTreePath *cursor_path; +@@ -12573,18 +13573,21 @@ + * path maps to a non-existing path and we will silently bail out. + * We unset tree and node to avoid further processing. + */ +- if (!row_is_separator (tree_view, NULL, path) +- && _gtk_tree_view_find_node (tree_view, path, &tree, &node) == FALSE) ++ if (tree_view->priv->hildon_mode == HILDON_DIABLO) + { +- tree_view->priv->cursor = +- gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), +- tree_view->priv->model, +- path); +- } +- else +- { +- tree = NULL; +- node = NULL; ++ if (!row_is_separator (tree_view, NULL, NULL, path) ++ && _gtk_tree_view_find_node (tree_view, path, &tree, &node) == FALSE) ++ { ++ tree_view->priv->cursor = ++ gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), ++ tree_view->priv->model, ++ path); ++ } ++ else ++ { ++ tree = NULL; ++ node = NULL; ++ } + } + + if (tree != NULL) +@@ -12596,8 +13599,13 @@ + { + GtkTreeSelectMode mode = 0; + +- if (tree_view->priv->modify_selection_pressed) +- mode |= GTK_TREE_SELECT_MODE_TOGGLE; ++ if (tree_view->priv->modify_selection_pressed || ++ (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT ++ && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE)) ++ { ++ mode |= GTK_TREE_SELECT_MODE_TOGGLE; ++ } + if (tree_view->priv->extend_selection_pressed) + mode |= GTK_TREE_SELECT_MODE_EXTEND; + +@@ -12622,7 +13630,9 @@ + } + } + +- g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0); ++ /* Only in the original mode we want to handle the cursor */ ++ if (tree_view->priv->hildon_mode == HILDON_DIABLO) ++ g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0); + } + + /** +@@ -13780,6 +14790,7 @@ + gboolean is_separator = FALSE; + gboolean rtl; + cairo_t *cr; ++ gboolean is_header = FALSE; + + g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL); + g_return_val_if_fail (path != NULL, NULL); +@@ -13804,7 +14815,7 @@ + path)) + return NULL; + +- is_separator = row_is_separator (tree_view, &iter, NULL); ++ is_separator = row_is_separator (tree_view, &iter, &is_header, NULL); + + cell_offset = x; + +@@ -13872,7 +14883,14 @@ + + if (gtk_tree_view_column_cell_is_visible (column)) + { +- if (is_separator) ++ if (is_header) ++ { ++ gtk_tree_view_draw_row_header (tree_view, ++ &iter, ++ NULL, ++ &cell_area); ++ } ++ else if (is_separator) + gtk_paint_hline (widget->style, + drawable, + GTK_STATE_NORMAL, +@@ -15141,6 +16159,83 @@ + gtk_widget_queue_resize (GTK_WIDGET (tree_view)); + } + ++HildonTreeViewRowHeaderFunc ++hildon_tree_view_get_row_header_func (GtkTreeView *tree_view) ++{ ++ g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL); ++ ++ return tree_view->priv->row_header_func; ++} ++ ++static void ++hildon_tree_view_setup_row_header_layout (GtkTreeView *tree_view) ++{ ++ GdkColor font_color; ++ GtkStyle *font_style; ++ GtkWidget *widget = GTK_WIDGET (tree_view); ++ ++ font_style = gtk_rc_get_style_by_paths (gtk_settings_get_default (), ++ "EmpSmallSystemFont", ++ NULL, G_TYPE_NONE); ++ if (font_style) ++ { ++ pango_layout_set_font_description (tree_view->priv->row_header_layout, ++ font_style->font_desc); ++ } ++ ++ if (gtk_style_lookup_color (widget->style, "SecondaryTextColor", &font_color)) ++ { ++ PangoAttrList *list; ++ PangoAttribute *attr; ++ ++ list = pango_attr_list_new (); ++ attr = pango_attr_foreground_new (font_color.red, ++ font_color.green, ++ font_color.blue); ++ attr->start_index = 0; ++ attr->end_index = G_MAXINT; ++ pango_attr_list_insert (list, attr); ++ ++ pango_layout_set_attributes (tree_view->priv->row_header_layout, ++ list); ++ ++ pango_attr_list_unref (list); ++ } ++} ++ ++void ++hildon_tree_view_set_row_header_func (GtkTreeView *tree_view, ++ HildonTreeViewRowHeaderFunc func, ++ gpointer data, ++ GDestroyNotify destroy) ++{ ++ g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); ++ ++ if (tree_view->priv->row_header_destroy) ++ (* tree_view->priv->row_header_destroy) (tree_view->priv->row_header_data); ++ ++ tree_view->priv->row_header_func = func; ++ tree_view->priv->row_header_data = data; ++ tree_view->priv->row_header_destroy = destroy; ++ ++ if (func && !tree_view->priv->row_header_layout) ++ { ++ tree_view->priv->row_header_layout = ++ gtk_widget_create_pango_layout (GTK_WIDGET (tree_view), ""); ++ ++ hildon_tree_view_setup_row_header_layout (tree_view); ++ } ++ else if (!func && tree_view->priv->row_header_layout) ++ { ++ g_object_unref (tree_view->priv->row_header_layout); ++ tree_view->priv->row_header_layout = NULL; ++ } ++ ++ /* Have the tree recalculate heights */ ++ _gtk_rbtree_mark_invalid (tree_view->priv->tree); ++ gtk_widget_queue_resize (GTK_WIDGET (tree_view)); ++} ++ + + static void + gtk_tree_view_grab_notify (GtkWidget *widget, +@@ -15156,6 +16251,21 @@ + + if (tree_view->priv->rubber_band_status) + gtk_tree_view_stop_rubber_band (tree_view); ++ ++ if (tree_view->priv->queued_expand_row) ++ { ++ gtk_tree_row_reference_free (tree_view->priv->queued_expand_row); ++ tree_view->priv->queued_expand_row = NULL; ++ } ++ ++ if (tree_view->priv->queued_tapped_row) ++ { ++ gtk_tree_row_reference_free (tree_view->priv->queued_tapped_row); ++ tree_view->priv->queued_tapped_row = NULL; ++ } ++ ++ free_queued_select_row (tree_view); ++ free_queued_activate_row (tree_view); + } + } + +@@ -15755,5 +16865,373 @@ + return tree_view->priv->tooltip_column; + } + ++static gboolean ++gtk_tree_view_tap_and_hold_query (GtkWidget *widget, ++ GdkEvent *event) ++{ ++ GtkTreeView *tree_view = GTK_TREE_VIEW (widget); ++ GtkTreePath *path; ++ GtkRBTree *tree = NULL; ++ GtkRBNode *node = NULL; ++ gdouble x, y; ++ gint new_y; ++ gboolean sensitive; ++ ++ if (!tree_view->priv->tree) ++ return FALSE; ++ ++ if (!gdk_event_get_coords (event, &x, &y)) ++ return FALSE; ++ ++ new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y); ++ if (new_y < 0) ++ new_y = 0; ++ _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node); ++ if (node == NULL) ++ return TRUE; ++ ++ path = _gtk_tree_view_find_path (tree_view, tree, node); ++ ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_NORMAL) ++ { ++ /* The normal mode has no notion of selection, so we special-case ++ * it here. ++ */ ++ sensitive = !row_is_separator (tree_view, NULL, NULL, path); ++ } ++ else ++ { ++ sensitive = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, ++ node, path); ++ } ++ ++ gtk_tree_path_free (path); ++ ++ return !sensitive; ++} ++ ++static void ++free_queued_select_row (GtkTreeView *tree_view) ++{ ++ /* We only clear the selected flag (used for highlight) if the node ++ * was previously *not* selected. ++ */ ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && gtk_tree_row_reference_valid (tree_view->priv->queued_select_row)) ++ { ++ if (tree_view->priv->highlighted_node) ++ { ++ _gtk_tree_view_queue_draw_node (tree_view, ++ tree_view->priv->highlighted_tree, ++ tree_view->priv->highlighted_node, ++ NULL); ++ ++ tree_view->priv->highlighted_tree = NULL; ++ tree_view->priv->highlighted_node = NULL; ++ } ++ } ++ ++ gtk_tree_row_reference_free (tree_view->priv->queued_select_row); ++ tree_view->priv->queued_select_row = NULL; ++} ++ ++static void ++free_queued_activate_row (GtkTreeView *tree_view) ++{ ++ if (tree_view->priv->hildon_mode == HILDON_FREMANTLE ++ && tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_NORMAL ++ && gtk_tree_row_reference_valid (tree_view->priv->queued_activate_row)) ++ { ++ if (tree_view->priv->highlighted_node) ++ { ++ _gtk_tree_view_queue_draw_node (tree_view, ++ tree_view->priv->highlighted_tree, ++ tree_view->priv->highlighted_node, ++ NULL); ++ ++ tree_view->priv->highlighted_tree = NULL; ++ tree_view->priv->highlighted_node = NULL; ++ } ++ } ++ ++ gtk_tree_row_reference_free (tree_view->priv->queued_activate_row); ++ tree_view->priv->queued_activate_row = NULL; ++} ++ ++static void ++free_queued_actions (GtkTreeView *tree_view) ++{ ++ free_queued_activate_row (tree_view); ++ free_queued_select_row (tree_view); ++ ++ gtk_tree_row_reference_free (tree_view->priv->queued_expand_row); ++ tree_view->priv->queued_expand_row = NULL; ++ ++ gtk_tree_row_reference_free (tree_view->priv->queued_tapped_row); ++ tree_view->priv->queued_tapped_row = NULL; ++} ++ ++HildonUIMode ++hildon_tree_view_get_hildon_ui_mode (GtkTreeView *tree_view) ++{ ++ g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0); ++ ++ return tree_view->priv->hildon_ui_mode; ++} ++ ++void ++hildon_tree_view_set_hildon_ui_mode (GtkTreeView *tree_view, ++ HildonUIMode hildon_ui_mode) ++{ ++ g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); ++ ++ /* Don't check if the new mode matches the old mode; always continue ++ * so that the selection corrections below always happen. ++ */ ++ tree_view->priv->hildon_ui_mode = hildon_ui_mode; ++ ++ if (tree_view->priv->hildon_mode == HILDON_DIABLO) ++ return; ++ ++ /* For both normal and edit mode a couple of things are disabled. */ ++ ++ /* Mode-specific settings */ ++ if (hildon_ui_mode == HILDON_UI_MODE_NORMAL) ++ { ++ gtk_tree_selection_set_mode (tree_view->priv->selection, ++ GTK_SELECTION_NONE); ++ } ++ else if (hildon_ui_mode == HILDON_UI_MODE_EDIT) ++ { ++ if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_NONE) ++ { ++ gtk_tree_selection_set_mode (tree_view->priv->selection, ++ GTK_SELECTION_SINGLE); ++ } ++ ++ if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE ++ && gtk_tree_selection_count_selected_rows (tree_view->priv->selection) < 1) ++ { ++ GtkTreePath *path; ++ ++ /* Select the first item */ ++ path = gtk_tree_path_new_first (); ++ search_first_focusable_path (tree_view, &path, ++ TRUE, NULL, NULL); ++ gtk_tree_selection_select_path (tree_view->priv->selection, path); ++ gtk_tree_path_free (path); ++ } ++ } ++ else ++ g_assert_not_reached (); ++} ++ ++static void ++hildon_tree_view_set_rows_offset (GtkTreeView *tree_view, ++ int rows_offset) ++{ ++ if (tree_view->priv->rows_offset == rows_offset) ++ return; ++ ++ tree_view->priv->rows_offset = rows_offset; ++ if (tree_view->priv->tree) ++ _gtk_rbtree_set_base_offset (tree_view->priv->tree, rows_offset); ++ ++ gtk_widget_queue_resize (GTK_WIDGET (tree_view)); ++} ++ ++static void ++hildon_tree_view_create_action_area (GtkTreeView *tree_view) ++{ ++ /* gtk_tree_view_put() takes over ownership and so we do not ++ * have to unref these values in gtk_tree_view_destroy(). ++ */ ++ tree_view->priv->action_area_event_box = gtk_event_box_new (); ++ gtk_tree_view_put (tree_view, tree_view->priv->action_area_event_box, ++ 0, 0, 0, 0); ++ ++ if (tree_view->priv->action_area_orientation == GTK_ORIENTATION_HORIZONTAL) ++ tree_view->priv->action_area_box = gtk_hbox_new (TRUE, 0); ++ else if (tree_view->priv->action_area_orientation == GTK_ORIENTATION_VERTICAL) ++ tree_view->priv->action_area_box = gtk_vbox_new (TRUE, 0); ++ ++ gtk_container_add (GTK_CONTAINER (tree_view->priv->action_area_event_box), ++ tree_view->priv->action_area_box); ++} ++ ++static void ++hildon_tree_view_set_action_area_height (GtkTreeView *tree_view) ++{ ++ if (tree_view->priv->action_area_orientation == GTK_ORIENTATION_HORIZONTAL) ++ { ++ int row_height; ++ ++ gtk_widget_style_get (GTK_WIDGET (tree_view), ++ "row-height", &row_height, ++ NULL); ++ hildon_tree_view_set_rows_offset (tree_view, row_height); ++ } ++ else if (tree_view->priv->action_area_orientation == GTK_ORIENTATION_VERTICAL) ++ { ++ GList *children; ++ ++ /* The height in portrait mode is currently hardcoded to 90px per ++ * button. ++ */ ++ children = gtk_container_get_children (GTK_CONTAINER (tree_view->priv->action_area_box)); ++ hildon_tree_view_set_rows_offset (tree_view, ++ g_list_length (children) * 90); ++ g_list_free (children); ++ } ++} ++ ++void ++hildon_tree_view_set_action_area_visible (GtkTreeView *tree_view, ++ gboolean visible) ++{ ++ g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); ++ ++ if (tree_view->priv->action_area_visible == !!visible) ++ return; ++ ++ tree_view->priv->action_area_visible = visible; ++ ++ if (visible) ++ { ++ hildon_tree_view_set_action_area_height (tree_view); ++ ++ if (!tree_view->priv->action_area_event_box) ++ hildon_tree_view_create_action_area (tree_view); ++ ++ gtk_widget_show (tree_view->priv->action_area_box); ++ gtk_widget_show (tree_view->priv->action_area_event_box); ++ } ++ else ++ { ++ gtk_widget_hide (tree_view->priv->action_area_event_box); ++ ++ hildon_tree_view_set_rows_offset (tree_view, 0); ++ } ++} ++ ++gboolean ++hildon_tree_view_get_action_area_visible (GtkTreeView *tree_view) ++{ ++ g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE); ++ ++ return tree_view->priv->action_area_visible; ++} ++ ++static void ++hildon_tree_view_rotate_action_area_box (GtkBox *old_box, ++ GtkBox *new_box) ++{ ++ int spacing, border_width; ++ GList *children, *child; ++ gboolean homogeneous; ++ ++ g_object_get (old_box, ++ "homogeneous", &homogeneous, ++ "spacing", &spacing, ++ "border-width", &border_width, ++ NULL); ++ ++ g_object_set (new_box, ++ "homogeneous", homogeneous, ++ "spacing", spacing, ++ "border-width", border_width, ++ NULL); ++ ++ children = gtk_container_get_children (GTK_CONTAINER (old_box)); ++ for (child = children; child; child = child->next) ++ { ++ guint padding; ++ gboolean expand, fill; ++ GtkPackType type; ++ GtkWidget *widget = child->data; ++ ++ g_object_ref (widget); ++ gtk_box_query_child_packing (old_box, widget, ++ &expand, &fill, &padding, &type); ++ gtk_container_remove (GTK_CONTAINER (old_box), widget); ++ gtk_container_add (GTK_CONTAINER (new_box), widget); ++ gtk_box_set_child_packing (new_box, widget, ++ expand, fill, padding, type); ++ g_object_unref (widget); ++ } ++ ++ g_list_free (children); ++ ++ if (gtk_widget_get_visible (GTK_WIDGET (old_box))) ++ gtk_widget_show (GTK_WIDGET (new_box)); ++} ++ ++void ++hildon_tree_view_set_action_area_orientation (GtkTreeView *tree_view, ++ GtkOrientation orientation) ++{ ++ GtkWidget *old_box; ++ GtkWidget *new_box; ++ ++ g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); ++ ++ if (tree_view->priv->action_area_orientation == orientation) ++ return; ++ ++ tree_view->priv->action_area_orientation = orientation; ++ ++ old_box = tree_view->priv->action_area_box; ++ if (orientation == GTK_ORIENTATION_HORIZONTAL) ++ new_box = gtk_hbox_new (TRUE, 0); ++ else if (orientation == GTK_ORIENTATION_VERTICAL) ++ new_box = gtk_vbox_new (TRUE, 0); ++ ++ if (tree_view->priv->action_area_visible) ++ hildon_tree_view_set_action_area_height (tree_view); ++ ++ hildon_tree_view_rotate_action_area_box (GTK_BOX (old_box), ++ GTK_BOX (new_box)); ++ ++ gtk_widget_destroy (old_box); ++ ++ tree_view->priv->action_area_box = new_box; ++ gtk_container_add (GTK_CONTAINER (tree_view->priv->action_area_event_box), ++ tree_view->priv->action_area_box); ++} ++ ++GtkOrientation ++hildon_tree_view_get_action_area_orientation (GtkTreeView *tree_view) ++{ ++ g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0); ++ ++ return tree_view->priv->action_area_orientation; ++} ++ ++/** ++ * hildon_tree_view_get_action_area_box: ++ * @tree_view: a #GtkTreeView ++ * ++ * Returns the GtkBox is embedded in GtkTreeView's action area. Depending ++ * on the setting of the GtkTreeView:action-area-orientation property ++ * this is either a GtkHBox or GtkVBox. You do not own a reference to ++ * the returned widget and thus this value should not be unreferenced. ++ * ++ * Returns: a pointer to a GtkBox. This pointer should not be unreferenced. ++ * ++ * Since: maemo 5.0 ++ * Stability: unstable ++ */ ++GtkWidget * ++hildon_tree_view_get_action_area_box (GtkTreeView *tree_view) ++{ ++ g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL); ++ ++ if (!tree_view->priv->action_area_event_box) ++ hildon_tree_view_create_action_area (tree_view); ++ ++ return tree_view->priv->action_area_box; ++} ++ + #define __GTK_TREE_VIEW_C__ + #include "gtkaliasdef.c" +--- a/gtk/gtktreeview.h ++++ b/gtk/gtktreeview.h +@@ -111,7 +111,8 @@ + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); +- void (*_gtk_reserved4) (void); ++ void (* row_insensitive) (GtkTreeView *tree_view, ++ GtkTreePath *path); + }; + + +@@ -134,7 +135,10 @@ + typedef void (*GtkTreeViewSearchPositionFunc) (GtkTreeView *tree_view, + GtkWidget *search_dialog, + gpointer user_data); +- ++typedef gboolean (*HildonTreeViewRowHeaderFunc) (GtkTreeModel *model, ++ GtkTreeIter *iter, ++ gchar **header_text, ++ gpointer data); + + /* Creators */ + GType gtk_tree_view_get_type (void) G_GNUC_CONST; +@@ -392,6 +396,27 @@ + gpointer data, + GDestroyNotify destroy); + ++HildonTreeViewRowHeaderFunc hildon_tree_view_get_row_header_func (GtkTreeView *tree_view); ++void hildon_tree_view_set_row_header_func (GtkTreeView *tree_view, ++ HildonTreeViewRowHeaderFunc func, ++ gpointer data, ++ GDestroyNotify destroy); ++ ++HildonUIMode hildon_tree_view_get_hildon_ui_mode (GtkTreeView *tree_view); ++void hildon_tree_view_set_hildon_ui_mode (GtkTreeView *tree_view, ++ HildonUIMode mode); ++ ++ ++void hildon_tree_view_set_action_area_visible (GtkTreeView *tree_view, ++ gboolean visible); ++gboolean hildon_tree_view_get_action_area_visible (GtkTreeView *tree_view); ++ ++void hildon_tree_view_set_action_area_orientation (GtkTreeView *tree_view, ++ GtkOrientation orientation); ++GtkOrientation hildon_tree_view_get_action_area_orientation (GtkTreeView *tree_view); ++ ++GtkWidget *hildon_tree_view_get_action_area_box (GtkTreeView *tree_view); ++ + GtkTreeViewGridLines gtk_tree_view_get_grid_lines (GtkTreeView *tree_view); + void gtk_tree_view_set_grid_lines (GtkTreeView *tree_view, + GtkTreeViewGridLines grid_lines); +--- a/gtk/gtktreeprivate.h ++++ b/gtk/gtktreeprivate.h +@@ -28,7 +28,7 @@ + #include + #include + +-#define TREE_VIEW_DRAG_WIDTH 6 ++#define TREE_VIEW_DRAG_WIDTH 28 + + typedef enum + { +@@ -300,6 +300,37 @@ + + /* Whether our key press handler is to avoid sending an unhandled binding to the search entry */ + guint search_entry_avoid_unhandled_binding : 1; ++ ++ /* Fields for Maemo specific functionality */ ++ GtkTreeRowReference *queued_select_row; ++ GtkTreeRowReference *queued_expand_row; ++ GtkTreeRowReference *queued_activate_row; ++ GtkTreeRowReference *queued_tapped_row; ++ ++ GtkRBNode *highlighted_node; ++ GtkRBTree *highlighted_tree; ++ ++ GtkTreeCellDataHint cell_data_hint; ++ ++ HildonUIMode hildon_ui_mode; ++ HildonMode hildon_mode; ++ ++ GdkPixbuf *tickmark_icon; ++ ++ HildonTreeViewRowHeaderFunc row_header_func; ++ gpointer row_header_data; ++ GDestroyNotify row_header_destroy; ++ PangoLayout *row_header_layout; ++ ++ gint rows_offset; ++ GtkOrientation action_area_orientation; ++ GtkWidget *action_area_event_box; ++ GtkWidget *action_area_box; ++ ++ guint queued_shift_pressed : 1; ++ guint queued_ctrl_pressed : 1; ++ ++ guint action_area_visible : 1; + }; + + #ifdef __GNUC__ +--- a/gtk/gtktreeviewcolumn.c ++++ b/gtk/gtktreeviewcolumn.c +@@ -851,7 +851,7 @@ + G_CALLBACK (gtk_tree_view_column_button_clicked), + tree_column); + +- tree_column->alignment = gtk_alignment_new (tree_column->xalign, 0.5, 0.0, 0.0); ++ tree_column->alignment = gtk_alignment_new (tree_column->xalign, 0.5, 1.0, 1.0); + + hbox = gtk_hbox_new (FALSE, 2); + tree_column->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN); +@@ -916,7 +916,7 @@ + + /* Set up the actual button */ + gtk_alignment_set (GTK_ALIGNMENT (alignment), tree_column->xalign, +- 0.5, 0.0, 0.0); ++ 0.5, 1.0, 1.0); + + if (tree_column->child) + { +@@ -926,6 +926,7 @@ + current_child); + gtk_container_add (GTK_CONTAINER (alignment), + tree_column->child); ++ current_child = tree_column->child; + } + } + else +@@ -948,6 +949,14 @@ + ""); + } + ++ if (GTK_IS_MISC (current_child)) ++ { ++ gfloat yalign; ++ ++ gtk_misc_get_alignment (GTK_MISC (current_child), NULL, &yalign); ++ gtk_misc_set_alignment (GTK_MISC (current_child), tree_column->xalign, yalign); ++ } ++ + if (GTK_IS_TREE_SORTABLE (model)) + gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model), + &sort_column_id, +@@ -2536,6 +2545,100 @@ + } + + /** ++ * gtk_tree_view_column_cell_set_cell_data_with_hint: ++ * @tree_column: A #GtkTreeViewColumn. ++ * @tree_model: The #GtkTreeModel to to get the cell renderers attributes from. ++ * @iter: The #GtkTreeIter to to get the cell renderer's attributes from. ++ * @is_expander: %TRUE, if the row has children ++ * @is_expanded: %TRUE, if the row has visible children ++ * @hint: A #GtkTreeCellDataHint for the #GtkTreeCellDataFunc. ++ * ++ * Sets the cell renderer based on the @tree_model and @iter. That is, for ++ * every attribute mapping in @tree_column, it will get a value from the set ++ * column on the @iter, and use that value to set the attribute on the cell ++ * renderer. The @hint is a hint for the #GtkTreeCellDataFunc so that it does not ++ * have to set all cell renderer properties, possible leading to some ++ * optimizations. This is used primarily by the #GtkTreeView. ++ * ++ * Since: maemo 4.0 ++ * Stability: Unstable ++ **/ ++void ++gtk_tree_view_column_cell_set_cell_data_with_hint (GtkTreeViewColumn *tree_column, ++ GtkTreeModel *tree_model, ++ GtkTreeIter *iter, ++ gboolean is_expander, ++ gboolean is_expanded, ++ GtkTreeCellDataHint hint) ++{ ++ GSList *list; ++ GValue value = { 0, }; ++ GList *cell_list; ++ ++ g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column)); ++ ++ if (tree_model == NULL) ++ return; ++ ++ GTK_TREE_VIEW (tree_column->tree_view)->priv->cell_data_hint = hint; ++ ++ for (cell_list = tree_column->cell_list; cell_list; cell_list = cell_list->next) ++ { ++ GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) cell_list->data; ++ GObject *cell = (GObject *) info->cell; ++ ++ list = info->attributes; ++ ++ g_object_freeze_notify (cell); ++ ++ if (info->cell->is_expander != is_expander) ++ g_object_set (cell, "is-expander", is_expander, NULL); ++ ++ if (info->cell->is_expanded != is_expanded) ++ g_object_set (cell, "is-expanded", is_expanded, NULL); ++ ++ while (list && list->next) ++ { ++ gtk_tree_model_get_value (tree_model, iter, ++ GPOINTER_TO_INT (list->next->data), ++ &value); ++ g_object_set_property (cell, (gchar *) list->data, &value); ++ g_value_unset (&value); ++ list = list->next->next; ++ } ++ ++ if (info->func) ++ (* info->func) (tree_column, info->cell, tree_model, iter, info->func_data); ++ g_object_thaw_notify (G_OBJECT (info->cell)); ++ } ++} ++ ++/** ++ * gtk_tree_view_column_get_cell_data_hint: ++ * @tree_column: A #GtkTreeViewColumn. ++ * ++ * Returns the current value of the cell data hint as a ++ * #GtkTreeCellDataHint. Note that the value returned is only ++ * valid when called from a #GtkTreeCellDataFunc. The value of the hint ++ * tells you why the #GtkTreeView is calling the #GtkTreeCellDataFunc. ++ * Based on this hint, you can omit to generate the data and set certain ++ * cell renderer properties to improve performance. ++ * ++ * Return value: A #GtkTreeCellDataHint with the hint. ++ * ++ * Since: maemo 4.0 ++ * Stability: Unstable ++ */ ++GtkTreeCellDataHint ++gtk_tree_view_column_get_cell_data_hint (GtkTreeViewColumn *tree_column) ++{ ++ g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0); ++ g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_column->tree_view), 0); ++ ++ return GTK_TREE_VIEW (tree_column->tree_view)->priv->cell_data_hint; ++} ++ ++/** + * gtk_tree_view_column_cell_set_cell_data: + * @tree_column: A #GtkTreeViewColumn. + * @tree_model: The #GtkTreeModel to to get the cell renderers attributes from. +@@ -2564,6 +2667,8 @@ + if (tree_model == NULL) + return; + ++ GTK_TREE_VIEW (tree_column->tree_view)->priv->cell_data_hint = GTK_TREE_CELL_DATA_HINT_ALL; ++ + for (cell_list = tree_column->cell_list; cell_list; cell_list = cell_list->next) + { + GtkTreeViewColumnCellInfo *info = (GtkTreeViewColumnCellInfo *) cell_list->data; +--- a/gtk/gtktreeviewcolumn.h ++++ b/gtk/gtktreeviewcolumn.h +@@ -238,6 +238,25 @@ + void gtk_tree_view_column_queue_resize (GtkTreeViewColumn *tree_column); + GtkWidget *gtk_tree_view_column_get_tree_view (GtkTreeViewColumn *tree_column); + ++/** ++ * GtkTreeCellDataHint: ++ * ++ * See gtk_tree_view_column_get_cell_data_hint(). ++ **/ ++typedef enum ++{ ++ GTK_TREE_CELL_DATA_HINT_ALL, ++ GTK_TREE_CELL_DATA_HINT_KEY_FOCUS, ++ GTK_TREE_CELL_DATA_HINT_SENSITIVITY ++} GtkTreeCellDataHint; ++ ++void gtk_tree_view_column_cell_set_cell_data_with_hint (GtkTreeViewColumn *tree_column, ++ GtkTreeModel *tree_model, ++ GtkTreeIter *iter, ++ gboolean is_expander, ++ gboolean is_expanded, ++ GtkTreeCellDataHint hint); ++GtkTreeCellDataHint gtk_tree_view_column_get_cell_data_hint (GtkTreeViewColumn *tree_column); + + G_END_DECLS + +--- a/gtk/gtktreeselection.c ++++ b/gtk/gtktreeselection.c +@@ -25,6 +25,7 @@ + #include "gtkmarshalers.h" + #include "gtkintl.h" + #include "gtkalias.h" ++#include "gtkcelllayout.h" + + static void gtk_tree_selection_finalize (GObject *object); + static gint gtk_tree_selection_real_select_all (GtkTreeSelection *selection); +@@ -160,12 +161,24 @@ + GtkSelectionMode type) + { + GtkTreeSelectionFunc tmp_func; ++ HildonMode mode; + g_return_if_fail (GTK_IS_TREE_SELECTION (selection)); + + if (selection->type == type) + return; + +- ++ gtk_widget_style_get (GTK_WIDGET (selection->tree_view), ++ "hildon-mode", &mode, ++ NULL); ++ ++ if (mode == HILDON_FREMANTLE ++ && selection->tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_NORMAL ++ && type != GTK_SELECTION_NONE) ++ { ++ g_warning ("Cannot change the selection mode to anything other than GTK_SELECTION_NONE if hildon-ui-mode is GTK_HILDON_UI_MODE_NORMAL.\n"); ++ return; ++ } ++ + if (type == GTK_SELECTION_NONE) + { + /* We do this so that we unconditionally unset all rows +@@ -202,6 +215,47 @@ + } + } + ++ if (!selected ++ && mode == HILDON_FREMANTLE ++ && selection->tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT) ++ { ++ GList *rows; ++ ++ /* One item must stay selected; we look for the first selected ++ * item we can find, that one becomes the anchor. We silently ++ * assume here that there is at least *one* selected row, ++ * as mandated by any new-style edit mode. When switching ++ * from SELECTION_NONE there is no selected row, and the ++ * tree view will be responsible for selecting a node. ++ */ ++ ++ if (anchor_path) ++ gtk_tree_path_free (anchor_path); ++ ++ /* FIXME: this can be obviously optimized by walking ++ * the selection tree ourselves; or probably having a _real ++ * variant of _get_selected_rows() that we can tell to stop ++ * as soon as a selected node is found. ++ */ ++ rows = gtk_tree_selection_get_selected_rows (selection, NULL); ++ if (rows) ++ { ++ anchor_path = gtk_tree_path_copy (rows->data); ++ g_list_foreach (rows, (GFunc)gtk_tree_path_free, NULL); ++ g_list_free (rows); ++ ++ _gtk_tree_view_find_node (selection->tree_view, ++ anchor_path, ++ &tree, ++ &node); ++ ++ if (node && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED)) ++ selected = TRUE; ++ ++ g_return_if_fail (selected == TRUE); ++ } ++ } ++ + /* We do this so that we unconditionally unset all rows + */ + tmp_func = selection->user_func; +@@ -221,6 +275,23 @@ + } + + selection->type = type; ++ ++ if (type == GTK_SELECTION_SINGLE ++ || type == GTK_SELECTION_BROWSE) ++ { ++ GtkTreeIter iter; ++ ++ /* Make sure the cursor is on a selected node */ ++ if (gtk_tree_selection_get_selected (selection, NULL, &iter)) ++ { ++ GtkTreePath *path; ++ ++ path = gtk_tree_model_get_path (selection->tree_view->priv->model, ++ &iter); ++ gtk_tree_view_set_cursor (selection->tree_view, path, NULL, FALSE); ++ gtk_tree_path_free (path); ++ } ++ } + } + + /** +@@ -1249,6 +1320,39 @@ + g_signal_emit (selection, tree_selection_signals[CHANGED], 0); + } + ++static gboolean ++tree_column_is_sensitive (GtkTreeViewColumn *column, ++ GtkTreeModel *model, ++ GtkTreeIter *iter) ++{ ++ GList *cells, *list; ++ gboolean sensitive = TRUE; ++ gboolean visible; ++ ++ gtk_tree_view_column_cell_set_cell_data_with_hint (column, model, ++ iter, FALSE, FALSE, ++ GTK_TREE_CELL_DATA_HINT_SENSITIVITY); ++ ++ cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column)); ++ ++ list = cells; ++ while (list) ++ { ++ g_object_get (list->data, ++ "sensitive", &sensitive, ++ "visible", &visible, ++ NULL); ++ ++ if (visible && sensitive) ++ break; ++ ++ list = list->next; ++ } ++ g_list_free (cells); ++ ++ return sensitive; ++} ++ + gboolean + _gtk_tree_selection_row_is_selectable (GtkTreeSelection *selection, + GtkRBNode *node, +@@ -1256,6 +1360,17 @@ + { + GtkTreeIter iter; + gboolean sensitive = FALSE; ++ GList *list; ++ HildonMode mode; ++ ++ gtk_widget_style_get (GTK_WIDGET (selection->tree_view), ++ "hildon-mode", &mode, ++ NULL); ++ ++ /* normal-mode does not support selections */ ++ if (mode == HILDON_FREMANTLE ++ && selection->tree_view->priv->hildon_ui_mode == HILDON_UI_MODE_NORMAL) ++ return FALSE; + + if (!gtk_tree_model_get_iter (selection->tree_view->priv->model, &iter, path)) + sensitive = TRUE; +@@ -1269,6 +1384,29 @@ + return FALSE; + } + ++ if (!sensitive && selection->tree_view->priv->row_header_func) ++ { ++ /* never allow separators to be selected */ ++ if ((* selection->tree_view->priv->row_header_func) (selection->tree_view->priv->model, ++ &iter, ++ NULL, ++ selection->tree_view->priv->row_header_data)) ++ return FALSE; ++ } ++ ++ for (list = selection->tree_view->priv->columns; list && !sensitive; list = list->next) ++ { ++ GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (list->data); ++ ++ if (!column->visible) ++ continue; ++ ++ sensitive = tree_column_is_sensitive (column, selection->tree_view->priv->model, &iter); ++ } ++ ++ if (!sensitive) ++ return FALSE; ++ + if (selection->user_func) + return (*selection->user_func) (selection, selection->tree_view->priv->model, path, + GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED), +@@ -1453,6 +1591,11 @@ + path = _gtk_tree_view_find_path (selection->tree_view, tree, node); + toggle = _gtk_tree_selection_row_is_selectable (selection, node, path); + gtk_tree_path_free (path); ++ ++ /* Allow unselecting an insensitive row */ ++ if (!toggle && !select ++ && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED)) ++ toggle = TRUE; + } + + if (toggle) diff --git a/maemo/gtk+2.0-maemo/xid-collision-debug.patch b/maemo/gtk+2.0-maemo/xid-collision-debug.patch new file mode 100644 index 000000000..d61238c3b --- /dev/null +++ b/maemo/gtk+2.0-maemo/xid-collision-debug.patch @@ -0,0 +1,15 @@ +--- gtk+-2.18.3/gdk/x11/gdkxid.c 2009-06-19 04:59:18.000000000 +0200 ++++ gtk+-2.18.3/gdk/x11/gdkxid.c.new 2009-07-22 11:30:12.000000000 +0200 +@@ -56,10 +56,10 @@ + if (!display_x11->xid_ht) + display_x11->xid_ht = g_hash_table_new ((GHashFunc) gdk_xid_hash, + (GEqualFunc) gdk_xid_equal); +- ++/* + if (g_hash_table_lookup (display_x11->xid_ht, xid)) + g_warning ("XID collision, trouble ahead"); +- ++*/ + g_hash_table_insert (display_x11->xid_ht, xid, data); + } + diff --git a/maemo/hildon-desktop/APKBUILD b/maemo/hildon-desktop/APKBUILD new file mode 100644 index 000000000..6db103ec0 --- /dev/null +++ b/maemo/hildon-desktop/APKBUILD @@ -0,0 +1,34 @@ +pkgname=hildon-desktop +pkgver=2.2.155 +pkgrel=1 +_rev=c178acc6e7aa3524f962be6442335da8b89fc808 +pkgdesc="Hildon desktop for Fremantle" +arch="all" +url="https://github.com/fremantle-gtk2/hildon-desktop" +license="GPL" +depends="libhildon libmatchbox2 libhildondesktop clutter gnome-menus2 profiled" +makedepends="mce-headers profiled-dev libmatchbox2-dev gnome-menus2-dev libhildondesktop-dev" +source="$pkgname-$_rev.tar.gz::https://github.com/fremantle-gtk2/hildon-desktop/archive/$_rev.tar.gz" + +builddir="$srcdir/hildon-desktop-$_rev" + +prepare() { + cd "$builddir" + sed -i -e 's/libpng12/libpng/g' configure.ac + sed -i -e 's/g_return_if_fail (!render_manager->priv->zoomed);//g' src/home/hd-render-manager.c + # Temp workaround for top-left button to appear in QEMU x86_64 + sed -i -e 's/MB_WM_OBJECT_TYPE(c)==HD_TYPE_TITLE_BAR/G_TYPE_CHECK_INSTANCE_TYPE(c, HD_TYPE_TITLE_BAR)/g' src/home/hd-title-bar.h +} + +build() { + cd "$builddir" + ./autogen.sh + ./configure --prefix=/usr + make +} + +package() { + cd "$builddir" + make DESTDIR="$pkgdir/" install +} +sha512sums="277724771169b94ffba5836ce7010e0330b93c76b9d3c1ebbe192c3e834b9c9e873a9802642d3ab6166ef99ad0d5eb822965b816bba9e87294db7c1d8a069c29 hildon-desktop-c178acc6e7aa3524f962be6442335da8b89fc808.tar.gz" diff --git a/maemo/hildon-theme-alpha/APKBUILD b/maemo/hildon-theme-alpha/APKBUILD new file mode 100644 index 000000000..0b65a2f5c --- /dev/null +++ b/maemo/hildon-theme-alpha/APKBUILD @@ -0,0 +1,20 @@ +pkgname=hildon-theme-alpha +pkgver=9.4 +pkgrel=1 +pkgdesc="Nokia Nseries Theme for Hildon" +arch="noarch" +url="https://github.com/fremantle-gtk2" +license="custom" +_source_deb="hildon-theme-alpha_9.4+0m5_all.deb" +source="https://maemo-repos.com/apt-mirror/mirror/downloads.maemo.nokia.com/fremantle/ssu/210/$_source_deb" + +package() { + mkdir -p "$pkgdir" + cd "$pkgdir" + + ar x "$srcdir/$_source_deb" + tar xfz data.tar.gz + mkdir -p etc/hildon + ln -s /usr/share/themes/alpha etc/hildon/theme +} +sha512sums="de7a58200e4407707157d5ebbe7a2f43f97c76d4e442cb694a4387393407e6baac63384c0fe078d9a706f300b7edf8d392c37f2396815fa25845bebba61b8a0d hildon-theme-alpha_9.4+0m5_all.deb" diff --git a/maemo/iphbd/APKBUILD b/maemo/iphbd/APKBUILD new file mode 100644 index 000000000..8a670d9c2 --- /dev/null +++ b/maemo/iphbd/APKBUILD @@ -0,0 +1,27 @@ +pkgname=iphbd +pkgver=0.0.17 +pkgrel=1 +_rev=17b3aadb542ef144969450a4939251ec78c82a7d +pkgdesc="IP heartbeat daemon" +arch="all" +url="https://github.com/fremantle-gtk2/iphbd" +license="GPL2" +depends="dbus dbus-glib" +makedepends="autoconf automake libtool dbus-glib-dev" +subpackages="$pkgname-dev" +source="$pkgname-$_rev.tar.gz::https://github.com/fremantle-gtk2/iphbd/archive/$_rev.tar.gz" + +builddir="$srcdir/iphbd-$_rev" + +build() { + cd "$builddir" + ./autogen.sh + ./configure --prefix=/usr + make +} + +package() { + cd "$builddir" + make DESTDIR="$pkgdir/" install +} +sha512sums="2ee02896ee9c7c434e5065a19e482cc70eca933a63192943cd7ce8b2cdb8ed1c1291a22b2bbd69e42864f9d4cc011b97083c3b14d0ab750ba7794002c1675f08 iphbd-17b3aadb542ef144969450a4939251ec78c82a7d.tar.gz" diff --git a/maemo/libdsme/APKBUILD b/maemo/libdsme/APKBUILD new file mode 100644 index 000000000..38baaef58 --- /dev/null +++ b/maemo/libdsme/APKBUILD @@ -0,0 +1,31 @@ +pkgname=libdsme +pkgver=0.60.30 +pkgrel=1 +pkgdesc="Libraries for programs that communicate with the Device State Management Entity" +arch="all" +url="https://github.com/fremantle-gtk2/libdsme" +license="GPL" +depends="dbus glib" +depends_dev="glib-dev" +makedepends="bash glib-dev" +subpackages="$pkgname-dev" +_rev=3b90fe5a1c6be37ba507d036686649d687cb39ae +source="$pkgname-$_rev.tar.gz::https://github.com/fremantle-gtk2/libdsme/archive/$_rev.tar.gz" + +_builddir="$srcdir/libdsme-$_rev" + +prepare() { + cd "$_builddir" + sed -i -e "s||\n#include |g" ./protocol.c +} + +build() { + cd "$_builddir" + make +} + +package() { + cd "$_builddir" + make DESTDIR="$pkgdir/" install +} +sha512sums="ce3e6c8ef6543c317d7c5713b6f37b726b757de5e698757a26e308867d102c93a46c5a3900635ab2bff6e72b0ad884195b92d7aa53ec01263861afc876907eb2 libdsme-3b90fe5a1c6be37ba507d036686649d687cb39ae.tar.gz" diff --git a/maemo/libhildon/APKBUILD b/maemo/libhildon/APKBUILD new file mode 100644 index 000000000..e811a1fb2 --- /dev/null +++ b/maemo/libhildon/APKBUILD @@ -0,0 +1,31 @@ +pkgname=libhildon +pkgver=2.2.25 +pkgrel=1 +pkgdesc="Hildon libraries" +arch="all" +url="https://github.com/fremantle-gtk2/hildon" +license="GPL" +depends="gtk+2.0-maemo gconf libcanberra maemo-l10n pango" +depends_dev="gtk+2.0-maemo-dev libcanberra-dev gconf-dev" +makedepends="autoconf automake libtool gtk-doc $depends_dev" +_rev=954ebe8abe02e0b0e72db328ca1fed6a505be158 +subpackages="$pkgname-dev" +source="$pkgname-$_rev.tar.gz::https://github.com/fremantle-gtk2/hildon/archive/$_rev.tar.gz + hildon-non-glibc.patch" + +builddir="$srcdir/hildon-$_rev" + +build() { + cd "$builddir" + ./autogen.sh --prefix=/usr + make +} + +package() { + cd "$builddir" + make DESTDIR="$pkgdir/" install + # Prevent conflict with maemo-l10n + rm -rf "$pkgdir/usr/share/locale" +} +sha512sums="02a1f96b10c0547d96dab73d53c657803ea70a378a9fbdb93f30840180bbdc81c3320a3f6e24892da9a6acf5eda16eb6042d0758dfc921271e567bc0a66af82f libhildon-954ebe8abe02e0b0e72db328ca1fed6a505be158.tar.gz +5cc6578d513794276ed46292de9ecb72400477ffafa560ebbef2028c214e1a7c8e371f5179941cbfcb1865d2fc2db71e4f50f81e95a5173f247ec4412e312d12 hildon-non-glibc.patch" diff --git a/maemo/libhildon/hildon-non-glibc.patch b/maemo/libhildon/hildon-non-glibc.patch new file mode 100644 index 000000000..c9b9a2da7 --- /dev/null +++ b/maemo/libhildon/hildon-non-glibc.patch @@ -0,0 +1,66 @@ +diff --git a/configure.ac b/configure.ac +index 0410c83..4d2602f 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -74,6 +74,17 @@ AC_ARG_ENABLE(rebuilds, [ --disable-rebuilds disable all source autogenera + # is found, so autogenerated sources can be rebuilt + AC_CHECK_PROGS(PERL, perl5 perl) + ++# _NL_TIME_FIRST_WEEKDAY is an enum and not a define ++AC_MSG_CHECKING([for _NL_TIME_FIRST_WEEKDAY]) ++AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], ++ [[nl_langinfo(_NL_TIME_FIRST_WEEKDAY);]])], ++ [langinfo_ok=yes], [langinfo_ok=no]) ++AC_MSG_RESULT([$langinfo_ok]) ++if test "$langinfo_ok" = "yes"; then ++ AC_DEFINE([HAVE__NL_TIME_FIRST_WEEKDAY], [1], ++ [Define if _NL_TIME_FIRST_WEEKDAY is available]) ++fi ++ + REBUILD=\# + if test "x$enable_rebuilds" = "xyes" && \ + test -n "$PERL" && \ +diff --git a/hildon/hildon-calendar.c b/hildon/hildon-calendar.c +index b460e50..3c88f4c 100644 +--- a/hildon/hildon-calendar.c ++++ b/hildon/hildon-calendar.c +@@ -986,6 +986,7 @@ hildon_calendar_init (HildonCalendar *calendar) + else if (strcmp (year_before, "calendar:MY") != 0) + g_warning ("Whoever translated calendar:MY did so wrongly.\n"); + #endif ++#ifdef HAVE__NL_TIME_FIRST_WEEKDAY + langinfo = nl_langinfo (_NL_TIME_FIRST_WEEKDAY); + first_weekday = langinfo[0]; + langinfo = nl_langinfo (_NL_TIME_WEEK_1STDAY); +@@ -1012,6 +1013,9 @@ hildon_calendar_init (HildonCalendar *calendar) + } + + private_data->week_start = (week_1stday + first_weekday - 1) % 7; ++#else ++ private_data->week_start = 0; ++#endif + + locales_init (private_data); + } +diff --git a/hildon/hildon-weekday-picker.c b/hildon/hildon-weekday-picker.c +index d357c91..e436940 100644 +--- a/hildon/hildon-weekday-picker.c ++++ b/hildon/hildon-weekday-picker.c +@@ -211,6 +211,7 @@ hildon_weekday_picker_init (HildonWeekdayPicker *picker) + + sgroup = gtk_size_group_new (GTK_SIZE_GROUP_BOTH); + ++#ifdef HAVE__NL_TIME_FIRST_WEEKDAY + /* Check our first weekday */ + day = *nl_langinfo (_NL_TIME_FIRST_WEEKDAY); + +@@ -218,6 +219,9 @@ hildon_weekday_picker_init (HildonWeekdayPicker *picker) + /* Shift the days by one. This is done because GDateWeekday + * starts with Monday(1) and langinfo's first day is Sunday */ + day--; ++#else ++ day = 1; ++#endif + + if (day < 1) + day = 7; diff --git a/maemo/libhildondesktop/APKBUILD b/maemo/libhildondesktop/APKBUILD new file mode 100644 index 000000000..d37a46871 --- /dev/null +++ b/maemo/libhildondesktop/APKBUILD @@ -0,0 +1,26 @@ +pkgname=libhildondesktop +pkgver=2.1.43 +pkgrel=1 +_rev=813b16391359cccb1f100338dbb1530831e58784 +pkgdesc="Hildon Desktop library" +arch="all" +url="https://github.com/fremantle-gtk2/libhildondesktop" +license="GPL" +depends="libhildon iphbd dbus-glib" +makedepends="libhildon-dev iphbd-dev dbus-glib-dev" +subpackages="$pkgname-dev" +source="$pkgname-$_rev.tar.gz::https://github.com/fremantle-gtk2/libhildondesktop/archive/$_rev.tar.gz" + +builddir="$srcdir/libhildondesktop-$_rev" + +build() { + cd "$builddir" + ./autogen.sh --prefix=/usr CFLAGS="${CFLAGS} -Wno-error=unused-but-set-variable" + make +} + +package() { + cd "$builddir" + make DESTDIR="$pkgdir/" install +} +sha512sums="e6eb19fada805e3f5e19833f9d4f46d6677a9337287dd15bc0f186d70858cdfcb3e2b6713d18bbc54f61f8dc607f89dad13bcb17168918a16a23b149a0d35b3c libhildondesktop-813b16391359cccb1f100338dbb1530831e58784.tar.gz" diff --git a/maemo/libmatchbox2/APKBUILD b/maemo/libmatchbox2/APKBUILD new file mode 100644 index 000000000..6ec48fb03 --- /dev/null +++ b/maemo/libmatchbox2/APKBUILD @@ -0,0 +1,35 @@ +pkgname=libmatchbox2 +pkgver=0.2.92 +pkgrel=1 +_rev=e9c043acdd7a1659dc7fec003123548f309726ce +pkgdesc="Library for Matchbox Project applications" +arch="all" +url="https://github.com/fremantle-gtk2/libmatchbox2" +license="GPL" +depends="gtk+2.0-maemo pango libpng libxext clutter" +depends_dev="libxcomposite-dev libxext-dev libxdamage-dev" +makedepends="autoconf automake libtool + gtk+2.0-maemo-dev pango-dev clutter-dev libpng-dev $depends_dev" +subpackages="$pkgname-dev" +source="$pkgname-$_rev.tar.gz::https://github.com/fremantle-gtk2/libmatchbox2/archive/$_rev.tar.gz" + +builddir="$srcdir/libmatchbox2-$_rev" + +prepare() { + cd "$builddir" + sed -i -e 's/libpng12/libpng/g' configure.ac + sed -i -e 's/png_ptr->jmpbuf/png_jmpbuf(png_ptr)/g' matchbox/theme-engines/mb-wm-theme-png.c +} + +build() { + cd "$builddir" + autoreconf -i -f + ./configure --prefix=/usr --enable-png-theme --with-pango CFLAGS="${CFLAGS} -Wno-error=unused-result -Wno-error=deprecated-declarations" + make +} + +package() { + cd "$builddir" + make DESTDIR="$pkgdir/" install +} +sha512sums="eb3710ec32acdf8bfdf96605b711243d50ff4cbee856599dda7855b26109593476cac92218f4396c8beb247b72421bffe7a8ab7372f8070a899e6c03920b61a9 libmatchbox2-e9c043acdd7a1659dc7fec003123548f309726ce.tar.gz" diff --git a/maemo/maemo-l10n/APKBUILD b/maemo/maemo-l10n/APKBUILD new file mode 100644 index 000000000..99ee7b4aa --- /dev/null +++ b/maemo/maemo-l10n/APKBUILD @@ -0,0 +1,294 @@ +pkgname=maemo-l10n +pkgver=210 +pkgrel=1 +pkgdesc="Localization files for Maemo applications" +arch="noarch" +url="https://github.com/fremantle-gtk2" +license="GPL" +_url="https://maemo-repos.com/apt-mirror/mirror/downloads.maemo.nokia.com/fremantle/ssu/210" +subpackages="$pkgname-doc" +source="${_url}/hildon-libs-l10n-cscz_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-dadk_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-dede_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-engb_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-enus_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-eses_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-esmx_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-fifi_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-frca_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-frfr_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-itit_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-nlnl_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-nono_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-plpl_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-ptpt_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-ruru_6.0+r7987+0m5_all.deb + ${_url}/hildon-libs-l10n-svse_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-cscz_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-dadk_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-dede_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-engb_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-enus_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-eses_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-esmx_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-fifi_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-frca_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-frfr_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-itit_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-nlnl_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-nono_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-plpl_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-ptpt_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-ruru_6.0+r7987+0m5_all.deb + ${_url}/osso-system-lock-l10n-svse_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-cscz_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-dadk_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-dede_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-engb_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-enus_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-eses_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-esmx_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-fifi_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-frca_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-frfr_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-itit_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-nlnl_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-nono_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-plpl_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-ptpt_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-ruru_6.0+r7987+0m5_all.deb + ${_url}/hildon-fm-l10n-svse_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-cscz_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-dadk_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-dede_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-engb_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-enus_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-eses_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-esmx_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-fifi_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-frca_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-frfr_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-itit_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-nlnl_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-nono_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-plpl_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-ptpt_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-ruru_6.0+r7987+0m5_all.deb + ${_url}/osso-uri-l10n-svse_6.0+r7987+0m5_all.deb + ${_url}/osso-countries-l10n-cscz_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-dadk_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-dede_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-engb_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-enus_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-eses_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-esmx_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-fifi_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-frca_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-frfr_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-itit_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-nlnl_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-nono_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-plpl_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-ptpt_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-ruru_6.0+r7274+0m5_all.deb + ${_url}/osso-countries-l10n-svse_6.0+r7274+0m5_all.deb + ${_url}/osso-cities-l10n-cscz_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-dadk_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-dede_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-engb_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-enus_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-eses_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-esmx_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-fifi_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-frca_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-frfr_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-itit_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-nlnl_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-nono_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-plpl_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-ptpt_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-ruru_6.0+r7336+0m5_all.deb + ${_url}/osso-cities-l10n-svse_6.0+r7336+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-cscz_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-dadk_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-dede_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-engb_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-enus_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-eses_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-esmx_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-fifi_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-frca_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-frfr_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-itit_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-nlnl_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-nono_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-plpl_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-ptpt_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-ruru_6.0+r7987+0m5_all.deb + ${_url}/maemo-af-desktop-l10n-svse_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-cscz_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-dadk_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-dede_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-engb_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-enus_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-eses_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-esmx_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-fifi_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-frca_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-frfr_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-itit_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-nlnl_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-nono_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-plpl_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-ptpt_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-ruru_6.0+r7987+0m5_all.deb + ${_url}/ke-recv-l10n-svse_6.0+r7987+0m5_all.deb" + +package() { + mkdir -p "$pkgdir" + cd "$pkgdir" + + for i in $source + do + filename="$(basename $i)" + ar x "$srcdir/$filename" + tar xfz data.tar.gz + rm control.tar.gz data.tar.gz debian-binary + done +} +sha512sums="973fe9e072aab0fac7d3b4da91001eeb124792476ec8d8e4b434d65b2ea660806c83d05c4614557a6a47a933abe137ff1048cceaeda984fd325a9dfb6a7bcd94 hildon-libs-l10n-cscz_6.0+r7987+0m5_all.deb +17aff62eeab1767fd0a37f3fcf4b8e95356c5671a6dca7ba6d16a4ae6f248d4d5e591ae00baf315a3b18923d983309cd49d227ab7f9a091bfeb9ac1b183148e5 hildon-libs-l10n-dadk_6.0+r7987+0m5_all.deb +cf017c862bda77b00e6408e4e7875970109f5c97274173fcd5f1f6106a736336f2863c1730f1e1155c08b7baec6070edcee130abab942d891aceb3dc42efc3f3 hildon-libs-l10n-dede_6.0+r7987+0m5_all.deb +761b657a04fd7b0d022a0753a5e1247997d9bdc07a63e20fa2f4ec5e96c599613ee1df03f56e0440ce3d48792a227b9e3bae7467c68f326423af75a1fe231497 hildon-libs-l10n-engb_6.0+r7987+0m5_all.deb +4cccc4b90831ffc2f9c4241ed97f1092c47dcf1f68498a766015fa842eda36a38c86122d334bcd18783a75bfb31d80c65451cc9fba50f9228dba57efc56f1dc4 hildon-libs-l10n-enus_6.0+r7987+0m5_all.deb +230dbc67eae7dd41ae69c40809d2bb9e38c694f657b6d6f167dd068de9fdfead4f80cb9c54a67ff905b5645ac10f9741e498c0debd2070465cdbd238834ad8fb hildon-libs-l10n-eses_6.0+r7987+0m5_all.deb +c6eaaabe1c3534275c3ac43321d3c9500f4692c3789213f9b7b1da57d87fd229c5fbaedb7f98256c93873b44588f27c3fb2f127faa94bb055e7af4312461fdcd hildon-libs-l10n-esmx_6.0+r7987+0m5_all.deb +ce86f720f0e6b9fd43dd34ffa840f9075740e671a164d5b57c62651c29e9bce377952e6bd44ad2c37197ac11976fbf15b4527da968e38cf275a216ecc0ce774f hildon-libs-l10n-fifi_6.0+r7987+0m5_all.deb +c27fdbcd28218b6ecf3d58b1ea58753310ebbf9275c18d22e0d3768c634bc83c275a47be9c4a8d867fcba94ad57cb27d182ca32a91461887dce593bfa55dc1e4 hildon-libs-l10n-frca_6.0+r7987+0m5_all.deb +4df80a24f57da36ba79f3026e7873470d15229e5ccc1282deb352dc99849a93f837e5219a2a6f72bbda5e809debb5b115b7c8f47caf9d532f9c36e048854e7d8 hildon-libs-l10n-frfr_6.0+r7987+0m5_all.deb +a0936f78f51c2d04bfad7b53f7929f6badd1b3d8779165ea6ee527ada41071a23dcf762737993fd477ba41a405f6fababe8781fab849b91ed70fe2aa3bf1add2 hildon-libs-l10n-itit_6.0+r7987+0m5_all.deb +e7784c9794c0f2694efe77314397fb4d07b7e65b7f0bee338686558192bf32d39f1f9b0c18526dd2ff319a4aab09868c441ecdb032926840484dba0115e5279b hildon-libs-l10n-nlnl_6.0+r7987+0m5_all.deb +f9cc53285f46bb15b6f42a4d792c21467853cbbb6b4a8179cb20d4a60d00d7017e26f0967e40287cbf762f100a66df44b02697a186226e2069fb61b34531a97e hildon-libs-l10n-nono_6.0+r7987+0m5_all.deb +8ba699b78e988cafd74031dfd8c2247ae6c79ee7aa8398dfd2e8ff9aab41220e5adb501b3c47d382b7c5e3fb89aaed71eb268d051e3018fa41ec508f25e5fe79 hildon-libs-l10n-plpl_6.0+r7987+0m5_all.deb +4d0c6ad836db27146b6e3ef74fdd1a7b3d779a911e212fedb18d3c8bce2ac8b0af9958d4142acc5a22e8334c2adae4caeb8824255d76cb53ed4af7036053b3a3 hildon-libs-l10n-ptpt_6.0+r7987+0m5_all.deb +9b113520614e0312f02be7d48ea09f358b0e3147df0855669d5bdd8dd64781a4cda2707330da3371a54971e2cbcbe52acb322dffbad0ca91ab952b68472f5788 hildon-libs-l10n-ruru_6.0+r7987+0m5_all.deb +ba5d0c0e9b3992e1bd9f9259e7f38c50545191af82024a0109d885259c4f5ca34e14c2669b63b0aa415269b4ef84d56e0ae3e2b050401890f0cba4d8314a2ba8 hildon-libs-l10n-svse_6.0+r7987+0m5_all.deb +939953407a36e33586939c9800d44d15a7878c0eca496f90d517d96705cd21d8f0828c2d2f8b950c148b97d65e8fef176464c6733488eff4d265a61ea07ff6ad osso-system-lock-l10n-cscz_6.0+r7987+0m5_all.deb +973b867e7d097a3fb3cb6c18d5b5a979246378f2149cfd22f63bd724bf4b8fd4a60094c7acb447717e5648427ef9f5b437f97bca2418a1008f627b55be31b3cd osso-system-lock-l10n-dadk_6.0+r7987+0m5_all.deb +f7230c1e058a54e391bed0d8033b7256ba6e54c3166225112a7a76910101116288b9476ee1ea0d221dd4b2879aa9ee4baafb7034e491f207a6cd7d0018021b90 osso-system-lock-l10n-dede_6.0+r7987+0m5_all.deb +ebfcabdb8b5180b99c9970a64be834a4c5c32b1d6f7eb3eb37650e699653c56f4973f5ba04a74355f530e4598d4ab2526c6dda72072ed1eb3ccf167086abfeb5 osso-system-lock-l10n-engb_6.0+r7987+0m5_all.deb +126783d582bb2585218c0b2e09585b9b43690d1c391d1c574f64851bf355f51d46da7e710d99f2fb0d6fc7d200e0cbde03517da5ffd4c4113659f8523792d4d0 osso-system-lock-l10n-enus_6.0+r7987+0m5_all.deb +9c8ad927b2ce9b31e806550ac19bfe0b3b4679b456d1dd034c22dba5bc07102882a169b9c2437a896491148edcc8946a11c248dd4d517678dc7aea285d4cedc0 osso-system-lock-l10n-eses_6.0+r7987+0m5_all.deb +50a50ce435c930f20341fbc46fc927641708e253224a3c5b0201d350c36b3aaf73b5d3fa59abbad4b5652b0f0d290896cd491d5cf72f24a28ed0ffaab3de19c2 osso-system-lock-l10n-esmx_6.0+r7987+0m5_all.deb +8e08ed32f1b4f043ade1952cb70016d756ba44dd21eaaa68e4cac8aebf3884419b337a46ce6a87e144de7e9fd553fab216fad80b762ca99847cd587a6cb0a81e osso-system-lock-l10n-fifi_6.0+r7987+0m5_all.deb +f873ed441c1e43c2f95fdb032d4eb43756db854e211e7c82e873b36ab0f84a41d70097ba69e9fc54a93dd2880718253a326f9e108f772b18b2ebe35c4b5360aa osso-system-lock-l10n-frca_6.0+r7987+0m5_all.deb +0f7365a37f2d2afe3de64304e4804f2ba4bd4bbbf19731289f46519f30fe088db00cb6f2efe9c177e5c42f22f7e03cd95a58679f8423d26a5072d8e57807d557 osso-system-lock-l10n-frfr_6.0+r7987+0m5_all.deb +94ac522b20f731d665f3097f0eb6f316f7d183fbda9cc43a7a89d8dbb721cc81998a2daef6afb2617a39fc92585af23a476a18f5d6b0bf60af7ce70623a4f2d0 osso-system-lock-l10n-itit_6.0+r7987+0m5_all.deb +ca5ede4aad5b20c14cb0e285b889b7d4a6c437ba6a375bc6cd1e8c57c1bca2423bea5e4e5eaf49d48df50b14704791b0306ea931e7fca898563f5fdcbd491fdf osso-system-lock-l10n-nlnl_6.0+r7987+0m5_all.deb +7716135c18ba94ce4834e6ba4100e9b144ab6d7bb9c065b971ec7c9fcd8107bf3faffe5ba091d47cff60b13ab142acc90139f04e3379345f83017b157f9735fb osso-system-lock-l10n-nono_6.0+r7987+0m5_all.deb +bec7a537586c3a5ca06a8bf60d05d3f8f6c9b2ea5720fc5136a1c68fe1bb15e79fe903af8dd1f569ebbbea05c165764bee9a9d6d7ac300a985378cd55b7f9218 osso-system-lock-l10n-plpl_6.0+r7987+0m5_all.deb +59b8df7ed3ed64e1b0c6606f054ae15faaaa80e31126de46338a56002675b82c677615dbe8260fc54747007d996f18ba7a002a0aa5d12f4554ee3722c06e8f2c osso-system-lock-l10n-ptpt_6.0+r7987+0m5_all.deb +824ab69c0f0c4ed8f676bee296aa283008a954de8a80c3273614181af481eb82bbd9c7f19fc4853cce0d448239f0c7920b970a77fa9ea36678401d7143396fd8 osso-system-lock-l10n-ruru_6.0+r7987+0m5_all.deb +fa4c5f1bd8ede6b3351a40c47b73b8f3b2886fa5e4bccfbff259f8e92e9823fdd469ea91695624cc6b92e37bc5b50fb875bcd0c1b84a72b3d4cbf9821e2b56c8 osso-system-lock-l10n-svse_6.0+r7987+0m5_all.deb +d267bbfdae390ba2e02a4bf0b5f4321a4102afc8fefbcd4c63ed97b87e062816d6e0b9923f2957c99c762bbd1a97d572eee5a9d9840f3fba8359b6d2c3031688 hildon-fm-l10n-cscz_6.0+r7987+0m5_all.deb +695bb1c432443f71937f40215f88f9c572cd702dd9954ae4cecb6659a9292ab0a37fee301ed73e5ebd205fdf6d0cece4ec9e0908bf914e00c06de2fb54806673 hildon-fm-l10n-dadk_6.0+r7987+0m5_all.deb +3e195ee528896e2ba6597abd388a1d876273ce4273f0cbb0aa8f3706aa7d4f006987eabc942d6b333cdb2cca8f0e2b2c365f8cc8a55bc5f955b09f59cd9202e5 hildon-fm-l10n-dede_6.0+r7987+0m5_all.deb +d06beba3a27ebeb35a875801bba45b8d69ed355293f05db1f388da7fed7e417a33bf9e4e1f24295c077f59c8dba473f7ee42d8cba5ed070c002c0e5a9179c092 hildon-fm-l10n-engb_6.0+r7987+0m5_all.deb +8d74683dc9c76aec42878b1b2a9ef5cb2120c92140b71c52a3d595f6d17bf6bcf53f4deed4f6f276a55e25a405a279319f91e841ac7010c214ca8940959728fe hildon-fm-l10n-enus_6.0+r7987+0m5_all.deb +98c3c07a1a9083aad367fc93d23198062fff6d88d337c54b65e2030868f65cc7e79613a15e819ff8f5e52d0d4ce27fabea48bacedaab9f7cf69a6c5bba7dacac hildon-fm-l10n-eses_6.0+r7987+0m5_all.deb +eb2fb22eca825b5893a5a402a5ddd41df1ebc12157469b2fb3c6a2b03b4d16b7d25a0bd59fffb1d34f5d29ab8e9b85156fc69869f411d6c78a8bbc1674afbb83 hildon-fm-l10n-esmx_6.0+r7987+0m5_all.deb +a54261ed201f6d218fe56faf93fa304ef4cdbd753e8b13963cd6ecf5825b39147eb5b7332361b5bbcf03f200b9acbbf35972d9a2089227963bb58e7197c7ee3c hildon-fm-l10n-fifi_6.0+r7987+0m5_all.deb +f749c3e67cdb1ed62b6f00a8b9ba342e73185621a15af1ab079e404e81cf94340c66b2ee1fc7e0b5ecf6a33b2d5a64594c4e471658366426c2a724e532c7c902 hildon-fm-l10n-frca_6.0+r7987+0m5_all.deb +beae428b2dd6168c3865db48fb1cf6af0dd0b85ced35dbee2e4c57927bb4faec118de5da23c71b2e17873adcd58dda0778282d5171e8da55ccf40a140d48b592 hildon-fm-l10n-frfr_6.0+r7987+0m5_all.deb +553afe1322f5ccdf94247647a070a5730f78f476f91b75b79a36be8129c3748a83b73354a3022fa45b3909af67ae278c98bf2e93b799ae89f9ad8bf36daeb07c hildon-fm-l10n-itit_6.0+r7987+0m5_all.deb +f910ccf80e8cc0ebbea6e83eae5ffba702d37bdf5a6365ccc6d22f3fa912cc76a58f8ce2e0461f84bc3d334688f8cd240d22617c552fb8b228b3a30734f6e087 hildon-fm-l10n-nlnl_6.0+r7987+0m5_all.deb +939d2b2b649612684faf8a1837227ca45579079e9bb7cef9a576e4ed12c957d011ff6dd78dd065ecfee9d364125dd0704a98950bfe08a9427de7d7cd395aa0ae hildon-fm-l10n-nono_6.0+r7987+0m5_all.deb +d40681ed61f580d81450e8b60a3e80f2848e0d263287f38d886c6f45c64777f2f0acb5818f767873fbd087284d54aba5e69020415e120184759add1fe899aef7 hildon-fm-l10n-plpl_6.0+r7987+0m5_all.deb +212dbb5c672c3f8d208749e8befce14100e2607cab12e946a9f0279e969ea7e6b81f4e7b5f64f6e88e3fa732a6b4d0dd28270306f40b853952603fd7c3f77d48 hildon-fm-l10n-ptpt_6.0+r7987+0m5_all.deb +cc3d711b7aa8d58bfc5c31d9bef5128b8ec44c9092cee0adf5340d40e2242e313d02c2b4b60a2aaa5e4e30fe644064a4955891f2e25ab9716a04fe6568c6e479 hildon-fm-l10n-ruru_6.0+r7987+0m5_all.deb +d35ebd66e6ab960b7c88a5b69a517d65176c6b401ca029836e5b89383090868baaf6d3208062a717c754b67c3c500b32acd8fc0b0b6d03665e587488acfe68c6 hildon-fm-l10n-svse_6.0+r7987+0m5_all.deb +f6d5a841ae2d4edbb5954a5a54e9315ab2709bb063e5dd0b689bd5ca20b69b774026c14deb6c1eb0be79e9c485eae8707cfbac52bae82be11d4b0819ec05e5d9 osso-uri-l10n-cscz_6.0+r7987+0m5_all.deb +5f29fdb1e5f7c82f1ff6e0adc89a1da75d700f68e0fc84c2a7e0d8018ac51e5be04a4072351bb51252816e6f552142d25cf58cc1f4a23b2b2b30c28906d69e5d osso-uri-l10n-dadk_6.0+r7987+0m5_all.deb +b7266aaa7c2a7e954b66809b718ae84c7c966c8167b6de28d2950fa8fbf6a6d3fa65b2a5bc69ea3a70a003602f21181d363c9eeecf2198bebffceb05f1f7a2f2 osso-uri-l10n-dede_6.0+r7987+0m5_all.deb +3ae0f6cf46c346fecaae738e0df686519de46fefc0ac7e40fd8cc36c4a11639a3d4d96284e05d52480a08afc5a1b2ea458f267a5050011630ab0d691b9f51d06 osso-uri-l10n-engb_6.0+r7987+0m5_all.deb +eef0d8a29021f2f9a039f4c5f31cc182b8c62b4dcf9753262b0de16e549f8cc96a247901580e615a4bcd3e234cfb91e77b7ce064f0bf5d4d47306b68099a8755 osso-uri-l10n-enus_6.0+r7987+0m5_all.deb +44fedc480688fd980a0966445191b94aec6f9fb103772a9db6ac4d3a0da01891909214cbbb04ab8a694d64c6e64ceaec4d6bee49341bc8e83a1f9d264b747328 osso-uri-l10n-eses_6.0+r7987+0m5_all.deb +f4525790e1e37dbbf4230697af2c87f132970fd99b474f47812553dce9e1312b01abd5e45cc12c992c782e3da6fc4a883797acb9c13c5506574ea68013b6609e osso-uri-l10n-esmx_6.0+r7987+0m5_all.deb +6c000dc9b9d0cb89f1722ebf0dff0a7aa9bfcd1efa0ccb58480d9d71ee17e4d6f25026b49ca4b605d51dfbdd2d8d935921ac714504723f3078b82c8d9368f3e8 osso-uri-l10n-fifi_6.0+r7987+0m5_all.deb +8765d7e637a4e2de490f2fea5024099b54d7dd225970d6484f7bb54260989555fc7119fadbe1f09e4c5e90479d0c685cbe2e5d468577f2b5da704ac02acde704 osso-uri-l10n-frca_6.0+r7987+0m5_all.deb +093aacbae93aff20afbe2879e2dcff71efc0263fdf8ce3b0bd6442994844440a5072808dc6b0db46fce6c5a49485424da1b97224a1c63588bbd50424e1a7c7a5 osso-uri-l10n-frfr_6.0+r7987+0m5_all.deb +2d17ccec45b7d3455754c24731bd7c625d25b535e6246014ef236fa4ff9cd0e9585768655cbe81615b97b1de41c51cc41f327d6f9635b24f00c43a76b8bd6f43 osso-uri-l10n-itit_6.0+r7987+0m5_all.deb +b935d5a79ac6d9ac092b717aed56d73538e8e4213c2b5bd422f621f50dd5cd99839647b06b2b7806c6f841dfc8637b0bbaba50db840088627c118770c66229ef osso-uri-l10n-nlnl_6.0+r7987+0m5_all.deb +83c48e225f154a2632c05bbe04479f01475f55271cfa49f710fdc5a1dc14fb00dc41574634103ce1b676bc072c9959aa735fdd7a80a36ade59c84d41a4b48cf1 osso-uri-l10n-nono_6.0+r7987+0m5_all.deb +f1ff50332321482b44484ec21452db206098a945363621a66b6da2798ebad8df3bf5d283105b1580834b6a06191cc2cc852561ee52257b58d0f808adaba94f25 osso-uri-l10n-plpl_6.0+r7987+0m5_all.deb +788dd68ba1dbfed34e6ff44dae13db8977c981beb06505260cd9b4376083d19fd71d928fb49dd865ba4336450fa201574fedb061d77be933dffb585af61cc378 osso-uri-l10n-ptpt_6.0+r7987+0m5_all.deb +76b1bdf6120e4e9bc1f6182fd299447701e960b8aa2ee8067d17e8c1fdc0480d4c2376ca6bce13de84f8356aa2c5c3079c448c150a6c184619081563e06a5262 osso-uri-l10n-ruru_6.0+r7987+0m5_all.deb +1dfeb388277c48b187f4b0447bb4116ba6d5fde46b0192afcb65c95642ef6446f8c3d7c518c2ccfe61894a0f331f04e3ba412dc8167da141fa70a6a72a4b63c7 osso-uri-l10n-svse_6.0+r7987+0m5_all.deb +671c0e7c91e52f996d129d3c7e30e50b8aee0e845aada4514ca2952a29e916822a8b7aec7de066c2091a90f2d52af67d003effe7ea6180886b48265b66a63937 osso-countries-l10n-cscz_6.0+r7274+0m5_all.deb +b26d2aa3e21ae60095e9b383fbb5d6e78c27650de140c82a532add35cf89c186fd04f34d375656a27681e89386c5308e13fa333b79b3188d2d1e92171d9ad020 osso-countries-l10n-dadk_6.0+r7274+0m5_all.deb +c3083167602741378401f77325ca93b712290cfe9237fb29c3dbb01038d2d27511cb2e5b20c60bfbcdecb734e94dc211e8d3c52c17df3a0b5a9611dd3bfcfd09 osso-countries-l10n-dede_6.0+r7274+0m5_all.deb +0103fd17a5c260f019ee4b41b0241fced5891040072a04bd404250d927fe510ab2e4cb60a608e5fd44eafe3d29585c02402ab79733bcf8c5f3ff8056b041350e osso-countries-l10n-engb_6.0+r7274+0m5_all.deb +2488fc9ad11414fbf8f411cb09e003488e71f0378a8d77785a8e5f6152dd6ef95e61e1a9f912efdb04b884ef94fbf0a0543c0adca2f6aedc39cb7279baf1e4d1 osso-countries-l10n-enus_6.0+r7274+0m5_all.deb +83a1a079e7ef0bedae9bee561d21727b8ec955217ad89ab1e6aca1cb8d522eb95adac3c8c7211821da1a888a2342718ec48d1e6158e741662bece1326840d852 osso-countries-l10n-eses_6.0+r7274+0m5_all.deb +c7e95ba5cf15967c80a4fdff9533086363a2a05577a4c6985cd75e48348bedb5a97ba88bba8287c6b9534f9e82fa8431b6a1ad942a0b69d65e3da32681085ebe osso-countries-l10n-esmx_6.0+r7274+0m5_all.deb +0cdd8cd5f9c5acee518ce68999423e04f96cd9728ce7d350d85fd3fdf1d5c9de5d6abd5eb446e62916209b6ac1588bdad0906a4879b95cb286271fd87ddcb32a osso-countries-l10n-fifi_6.0+r7274+0m5_all.deb +b4e0fed33161c05b22a1417d613fb836c6995c6f0ba76df9e93d457160408f2e5bb035d91563c7c7d9ae0b9a7929c91a05ac9c94a061314dba6b7609ac2c056b osso-countries-l10n-frca_6.0+r7274+0m5_all.deb +425d2afbe5822696548db70846cb441a736e96ada569b567cf19e4fdfc9911d0b8289e982ba758ead0ec3510da107ae6f292e2c4be7043394659d2d594152c7d osso-countries-l10n-frfr_6.0+r7274+0m5_all.deb +7c3c251d3fc2419da32b299be6d20c989900a5f13c2979657b6bf3a267aaa8cf5b64361ac3998e5f48fe2549f5057d00e8eb22e55b090cbae5460f8d541f9a4b osso-countries-l10n-itit_6.0+r7274+0m5_all.deb +31e58f30235ed2a447705141bb8300fc5f3b776e867cfba64a3116aae5e64fd5bc6b22e32440e999b2504c55752e76dcdce58fff124e87512b8211a54b0c5694 osso-countries-l10n-nlnl_6.0+r7274+0m5_all.deb +9e44aa3a5da71a000739e93e1c0084a6e8ce5bd9860778146614069caeb24932a7a7e0f182b93c1083e02956368a5d88e2c26c098fe52082a723422263fb5f61 osso-countries-l10n-nono_6.0+r7274+0m5_all.deb +e06c2c87be6037d9c2be6bc81689bbf3b0c3b4201037602396c62ef4d0f6276812e793658b0383ab2cc7c2f926ee72aceb5f9a745a9569725ddbc2a9d4e2031d osso-countries-l10n-plpl_6.0+r7274+0m5_all.deb +2cec46a882d5089ed4d825bfece04dd91993ae6ca02764b8edd3b2a750794345bde8a70e6ea4c63eed319515e78e14a19452d17e4a2def9e12f145133d81c0c6 osso-countries-l10n-ptpt_6.0+r7274+0m5_all.deb +ef6b105a911cccdb06ea16f30f90ab925fa73d909b62c829139829144db3cc249c669f7f264374675d914802e754bf4be12ae019a9e02300dd594d5e6a13d35b osso-countries-l10n-ruru_6.0+r7274+0m5_all.deb +ed07a4f301cc44efd00b4704d261296d43141c36c6d320dec8447a896348b7aeeda6ca32300a275e287a4c395d77ecd960119a7e29367b5504a75aea452581b3 osso-countries-l10n-svse_6.0+r7274+0m5_all.deb +6d56b55ca00532970144a8c377a3bf2e052f7f8ef6e50712c89b3b9daf9ebb5f9372938ed33aae864c08875adb886e2445aac8708d32cc1b86c914014ba1d9ae osso-cities-l10n-cscz_6.0+r7336+0m5_all.deb +2cc2a1483bd669a760f4dc5321b87ed42ccf4a6cedac535f81199d6a5b852b277922e419aaba9296baa780eb134a8ab93742e9f6960693ed7cef1e401e84a3c0 osso-cities-l10n-dadk_6.0+r7336+0m5_all.deb +0ff558e69570a0faba1065b0c71452afe2a59bfc4ad3efef9c475d6c6b995e69e5b535a1ed37b789abfe9b01be9e211c5e5d335810a985444de503b5101f6e89 osso-cities-l10n-dede_6.0+r7336+0m5_all.deb +c4517a69d9bd02ebd88f7051645a362027cf87400b59418becd0392b6005a2430a3bd42b8edce49fd467a94313056c92166e47ed92ef08ec7f0896203732bbd1 osso-cities-l10n-engb_6.0+r7336+0m5_all.deb +ba7b03101b72097258218d01be4e477bd83b23ab054ff1cfe734d2b9942428d6d5581a9202f8fc009b169a44c01ec1113fadb43b6d6085b707a9902138e91d51 osso-cities-l10n-enus_6.0+r7336+0m5_all.deb +ef96a397e1f60fa66f8e62af38daafd77511ad260764d987d259912b20494f16e2ecc261ce30da76d1bec27d7c65cb0ab7178fb78a33dd43b1c982c4c330c264 osso-cities-l10n-eses_6.0+r7336+0m5_all.deb +e9a155019d759eb517d63c78eec5a8c82737d3bc557a0fb766d796b420f2a45538081a3f077e6f0f4d36bc27fb57d9e106c17fa07f7427aae1dc7f3e8c22d24c osso-cities-l10n-esmx_6.0+r7336+0m5_all.deb +1900d32166798bd7eda061bb9b1a24b306eeba5ed25499d3b9b9a22193ccadcc83642c95775a79e853ebd2d463359c881ca0b1aeb197e714a27688442726a2f4 osso-cities-l10n-fifi_6.0+r7336+0m5_all.deb +477e71a4dc9ccf7f3a1de3725eec62c5787c8e2a94ac29e768c6b96ca3e1d4c7804c584568c43690fea7ab14b7cb0ee8d7e7a8e56054b852613bc6f44f0f499d osso-cities-l10n-frca_6.0+r7336+0m5_all.deb +3053af2729c841ec46b6760df45604fd15a3c602001c7430bd1e0e593b72a3dbe36f57ce31d6dd8d434efb50c42b0aa91725a34c618e830ecddd9f62b21e79b2 osso-cities-l10n-frfr_6.0+r7336+0m5_all.deb +916799a160ffe0914bdb8a697dbf1c1e42951f0c77577b7571bb6789fbdadfd6897b1409654658a618875738e85e5197b4f230df0f45faffea5b2b7a0d47ad38 osso-cities-l10n-itit_6.0+r7336+0m5_all.deb +d3c2b27f34e22ac56ee97edafb8fdca1ceb95ddccb386480bf67b6a61482bcf532c0c4218360d9a65f0d7fc649717b00b84e02e8adfb563d2f4bc550968553f1 osso-cities-l10n-nlnl_6.0+r7336+0m5_all.deb +c40976be47bb289bf6ba2afc99969fac81acaa72b8f34d977b03aea9bbf647066637ba467310bfcbafc7ff476616068ca849ab5091afbc9fae1f05c6e0491cc5 osso-cities-l10n-nono_6.0+r7336+0m5_all.deb +a2b944c5ec862dfc5fec9e4aa6d0b822943aba54ee38eb18e0dd097368cb52a3a60f45cb12cc0f62ebb9f612053ae29ab39f0a1e0def4f4df21d067e31a14f8d osso-cities-l10n-plpl_6.0+r7336+0m5_all.deb +d3ff9af844a232e3a50b65b5d902442c1737dece5021db912b85a5a0da6936bbb9fd3f8886f35b19a0ec05621a4cec5ac22942ebb1b66cd176e7e6f5998f9fcd osso-cities-l10n-ptpt_6.0+r7336+0m5_all.deb +2c2aa6bcd97354ef39fcf2c443e996fee01287b0507efe4234830da9b8e463b0175000015da4d56cdbcb4bab0990c3f1d6bf16e033ef662010d930a6c030104f osso-cities-l10n-ruru_6.0+r7336+0m5_all.deb +d46c274deb57a0e74a0ab88d4f6adf1f0fe2011acfeb7d6067fb070d289737a7b9645999ef665913433b675d541400f2d9f6261a372e57dc987c64168c315792 osso-cities-l10n-svse_6.0+r7336+0m5_all.deb +7546145e85cdc1d7e75adbe0d75d2aa26fe377e44f43132c609c91df4940ff43be4a2031652efcd4afac5a930d8271a9baee68d933c8a71a10835e69a78c5925 maemo-af-desktop-l10n-cscz_6.0+r7987+0m5_all.deb +0de65654691cb77d3421a5b45c3e2cd4371dc1f93a9760e531158ea5e0dd648ce35a3830d75b85673b3611a9d925c48bc9e3b391d5a41c4a18fa0fe795e4db8f maemo-af-desktop-l10n-dadk_6.0+r7987+0m5_all.deb +07885c64c41aab1b0772c9d4f94b8fec42f7d3b37ac4e48917b9c3d8c3a78b1804e7cfe72fe88106de7d473b381f3fbae7f7f3f5e8cd004cda9f1b42c1c213c0 maemo-af-desktop-l10n-dede_6.0+r7987+0m5_all.deb +13585b161e495a49d05caef78820dfb525a933456cbb1b47878ca7277b289c840b1798b54f3820dcd3c3d2fef3e116e1641f4b5285e64dc1720e8f0bd1c720cb maemo-af-desktop-l10n-engb_6.0+r7987+0m5_all.deb +df9cce67940248d4df3b2f37e3042d133b193c9e3ba1f8f5373e4e7c137292e81d15f91137dbedf4709c7ad0f3cd47e2acfd51726e595fdf7b006241635c116a maemo-af-desktop-l10n-enus_6.0+r7987+0m5_all.deb +01d71a40391135a0d209c5ce20834102efe59809de1602737f33fc0c6a0f41ad0b53f8da0861cda70d04646ee3d56e7cb47818edb834ab23802355ad1f428c0f maemo-af-desktop-l10n-eses_6.0+r7987+0m5_all.deb +3fc98d2059e6bf80ca783ce233308d1970c7ff3b2bad2e6d9e54e0cdfe4e2fc301e6af5d41c6ff9475db05cddf6929a5270ea0ad5e84512b2170faf82d629395 maemo-af-desktop-l10n-esmx_6.0+r7987+0m5_all.deb +a5035ad8f7166c99ed585b3f146e60f0531c6f2f416f1930cd9af7b556e1a1258d218cf05aa101d204d9b950d50fd5466f1f09758fea30112f85229e9875b763 maemo-af-desktop-l10n-fifi_6.0+r7987+0m5_all.deb +ebab661c36de5b089b119f93b42f28d6fc8942f728721a5d298db7b69c0d9972625189d4815192ccd452ba0353053ef36de71ef9aaff48815e1242beab7db3b4 maemo-af-desktop-l10n-frca_6.0+r7987+0m5_all.deb +95ec85f0e8783803c31d4f0b9f8572cd71de5ffa04a077aa4c6a232067829260fb39817d2b7d4501362df0207b4913640003b618507b56105d7aa8d6d4a98e51 maemo-af-desktop-l10n-frfr_6.0+r7987+0m5_all.deb +6326993219cf8df98be8a771168018a61cd050678dc8d84c81bd37484566b79f3a88dfc7fd5232d5d744ba70f6312903a69a7403fdb53def63cb9235768fde40 maemo-af-desktop-l10n-itit_6.0+r7987+0m5_all.deb +77f99bf89fa6f864ebf71abb678cb0d285d0387f3d8d495ff432ae43a61413d2c1c11e085d125783af0cdedc29dded7aea563b7e536757711b53186a1dd962d8 maemo-af-desktop-l10n-nlnl_6.0+r7987+0m5_all.deb +75b8df2a6eae9d97f4d8cf751f271e65d5895eecfeee60798b58f6562c3b13bff5cce4e0d849ce80f64188c27614fb3fa313fac1b06e83076aa81370a4318229 maemo-af-desktop-l10n-nono_6.0+r7987+0m5_all.deb +9f5d302861b510f4007a1776f6de99496036bd28e98ee01e5d0fba1bf5c34014311a56d04cc3f3d79eece04000855d2396f797b353158a7442b9abb50d457728 maemo-af-desktop-l10n-plpl_6.0+r7987+0m5_all.deb +1aa39add6b9bf9957ee89c0d3969d19c0b9e85dcd873add7c32db86acbba2211aa2692badabed84974adff5702c7423bd79c82bce650d321a6bc5c813cb50630 maemo-af-desktop-l10n-ptpt_6.0+r7987+0m5_all.deb +95498b158c46c9fb9c5d33959e302676b79aa09a5b62b42d70369fcbc6bee1063cc12eb4f9e07fabe89f4ca8852968bf8c9d59370e7f05439e5395eda0fb3bb8 maemo-af-desktop-l10n-ruru_6.0+r7987+0m5_all.deb +cec24e336bc7a4c8e44cf529629f1eda8b48d42adc521863aef483847008162eb844c2dda3775aaa5bb9ed5f55f02fd6dd323d3416d67799e6e9dbe864211be7 maemo-af-desktop-l10n-svse_6.0+r7987+0m5_all.deb +5325e29fc2313a960fd8fda02495d5083e5b504f2f6d7ba0a3bacb5149803e5ff43f6cf8955d64e3c1f0fc3155dacbeb91934a875cb5c6bb5307dc1b4f44c0a8 ke-recv-l10n-cscz_6.0+r7987+0m5_all.deb +c3528fbf8b682446f485a7382732063035b715b39c11a73fa9f965c121d47c29a85be05c6f02aa8b08beff40d561148d7b76ff5939dc901d6ada9eb5521d0325 ke-recv-l10n-dadk_6.0+r7987+0m5_all.deb +c4566ae8079d463d22ddf21739fe163cc3f5bcc2f723e34fba2bf82d879c966ba6f5fc5d65a627cccd156fee91c44ff9113605f04a20fb13c8e75d6788b09687 ke-recv-l10n-dede_6.0+r7987+0m5_all.deb +9cc107b0e6d368a7cad3b96c4d6c6b907dd5ae05dbee3f944914dfed8ff560ebc8bc6ba024664c63bfe298a2a002cfd1450e854b03b850bd6f13b7c8358160ac ke-recv-l10n-engb_6.0+r7987+0m5_all.deb +424a3e0ffba51302fc384d6ca8cb344242e43183109d901eb46309a5fabcef779785b5486c001d91effc98fc9a79c4eb46895bbe75e130fb826e1d335c6fa55c ke-recv-l10n-enus_6.0+r7987+0m5_all.deb +e8a2a46fc1263e8817cbb14c982c6ace49081c5793d656c36a7150a431058c1142658244feccb4da35f5459d9d6e2b9a7f847d66054d9775d0e95538bef279f3 ke-recv-l10n-eses_6.0+r7987+0m5_all.deb +adbea156bd305a6124031313f495e5010c134b9278a3b6edf5c8f1b67d30e3b072c7fd1c57ebcbb0514d5ac0ec127726e438c18d97c134ba46a023c862cd914e ke-recv-l10n-esmx_6.0+r7987+0m5_all.deb +73accf0c241ce964ab704c0aa59549fe6f4e9a93c70e6a809ae7243e9c1f6226ea051989172ccc173610dfd61201bd7bf0bac012f2d6b6ca0927320187c93894 ke-recv-l10n-fifi_6.0+r7987+0m5_all.deb +c071d4d7626913216e5ba0289a086249c16990f4e78ccc0cfde5859120b738ab17069f7814ad5ad0f375ca7308c5d65ad53ebb8c30c9b29024e2a0209f8fd611 ke-recv-l10n-frca_6.0+r7987+0m5_all.deb +fc18da52202595dcbe275d858a34a36d00a90e02c1e7ebe9a217cae06f8b5d14f2b05f893d2660977e11f6843c102705f69f5d2fd9752a66fa417a598d2aea9d ke-recv-l10n-frfr_6.0+r7987+0m5_all.deb +1530930af738cc40f6c690e5feb7361641172f86aad8425065d9d18f89d8a6db2075064217a7d0e4b64b3bb1f64b4cdee4592bc97a7f1d2fe3c6cfffd6ba008d ke-recv-l10n-itit_6.0+r7987+0m5_all.deb +c6e5afeb749f57eeae5fed7875fa9f61e99861c28a635f78c6c8208fcb646760d508a7e842f6e6f4edacc9862589bb14aeed3a8a428449c1cd2280a5c122c40b ke-recv-l10n-nlnl_6.0+r7987+0m5_all.deb +02fbc265e2f14f8e9842e5868fea5c13eabccc9e51584fc4082ae6711815e618009b693a9302f60d5c3c3a1581b4531960763a3b840e775481f18179cf717c73 ke-recv-l10n-nono_6.0+r7987+0m5_all.deb +df3adbf69770e60f846ffae8857df211abd8415883cddbd5bba8b3901fe6101509a1f94026a3cdd5b8c4647e4c18b0da240403ce34199b9e530f49be7b562178 ke-recv-l10n-plpl_6.0+r7987+0m5_all.deb +1950be7298d26099f3f8b5c37fd0c9d903ee2dcdfe62a2f733513c45459c3fa41b3f785a28666b0de1a14d69b62df7eaf21b19f5763e40dc801639f10f2654ac ke-recv-l10n-ptpt_6.0+r7987+0m5_all.deb +73356ddea9fbbd1e729b875bbe8b35bf9874650783e5de02b8a0f71b8761bb6a016600fdec1cf72844ef9a4bee12f8aa966a56f681dd9a388e65a4fef661dc42 ke-recv-l10n-ruru_6.0+r7987+0m5_all.deb +e9ca1a4f992bd7eab3a6041f82382214190cdd7f68b4faf065ed0708d2fadfc83ec7fb2450a80cf3fc66e132c85c43af58470a455943882e03dc2e5fd51ace8e ke-recv-l10n-svse_6.0+r7987+0m5_all.deb" diff --git a/maemo/mce-headers/APKBUILD b/maemo/mce-headers/APKBUILD new file mode 100644 index 000000000..c31041fcb --- /dev/null +++ b/maemo/mce-headers/APKBUILD @@ -0,0 +1,26 @@ +pkgname=mce-headers +pkgver=1.8.19 +pkgrel=1 +pkgdesc="Development files for mce" +arch="noarch" +url="https://github.com/fremantle-gtk2/mce-dev" +license="LGPL-2.1" +makedepends="coreutils doxygen" +subpackages="$pkgname-doc" +_rev=4a1896a43d176b32ec2ea1248128be4f2ad720d0 +source="$pkgname-$_rev.tar.gz::https://github.com/fremantle-gtk2/mce-dev/archive/$_rev.tar.gz" + +builddir="$srcdir/mce-dev-$_rev" + +build() { + cd "$builddir" + mkdir doc +} + +package() { + cd "$builddir" + make DESTDIR="$pkgdir/" install + install -d $pkgdir/usr/share/doc/mce-doc/html/ + install -m 644 doc/html/* $pkgdir/usr/share/doc/mce-doc/html/ +} +sha512sums="5413c2dd407d2f90a791c6b423a90673b4aff6a2c8a4e7f7f7b3a3ab37f7a95003c10d1a215343a6d697b31766dc81eeba44a2bd32df7f03ced9bb9aa0918852 mce-headers-4a1896a43d176b32ec2ea1248128be4f2ad720d0.tar.gz" diff --git a/maemo/profiled/APKBUILD b/maemo/profiled/APKBUILD new file mode 100644 index 000000000..f0b239da8 --- /dev/null +++ b/maemo/profiled/APKBUILD @@ -0,0 +1,27 @@ +pkgname=profiled +pkgver=1.0.4 +pkgrel=1 +_rev=77ca133bb1755f556a431b1338c342ffbafba700 +pkgdesc="Maemo profile daemon, manages user settings" +arch="all" +url="https://github.com/fremantle-gtk2/profiled" +license="BSD" +depends="dbus dbus-glib" +makedepends="doxygen dbus-dev dbus-glib-dev" +subpackages="$pkgname-dev $pkgname-doc" +source="$pkgname-$_rev.tar.gz::https://github.com/fremantle-gtk2/profiled/archive/$_rev.tar.gz + profiled-fix-musl.patch" + +builddir="$srcdir/profiled-$_rev" + +build() { + cd "$builddir" + make +} + +package() { + cd "$builddir" + make ROOT="$pkgdir/" install +} +sha512sums="42dd82dc5d6aa825698fd425ecf3fc5eab11aa9d89e03d576179e321be39f2a0041775f3270e9cba5139ff87c7585aa519970404f787867bb59b2eb7c6da1a67 profiled-77ca133bb1755f556a431b1338c342ffbafba700.tar.gz +21d0bd943c165de35223fc7003da8438eb77f7450810ce0a4ba8d0ae918c3af36f286503d568fe97e534e9a52463cd657b00277cc7ff010869e43453b6142328 profiled-fix-musl.patch" diff --git a/maemo/profiled/profiled-fix-musl.patch b/maemo/profiled/profiled-fix-musl.patch new file mode 100644 index 000000000..1acc6921c --- /dev/null +++ b/maemo/profiled/profiled-fix-musl.patch @@ -0,0 +1,21 @@ +diff --git a/profiled_config.h b/profiled_config.h +index 931aa9e..b4df46f 100644 +--- a/profiled_config.h ++++ b/profiled_config.h +@@ -42,6 +42,16 @@ extern "C" { + } /* fool JED indentation ... */ + #endif + ++/* taken from glibc unistd.h and fixes musl */ ++#ifndef TEMP_FAILURE_RETRY ++#define TEMP_FAILURE_RETRY(expression) \ ++ (__extension__ \ ++ ({ long int __result; \ ++ do __result = (long int) (expression); \ ++ while (__result == -1L && errno == EINTR); \ ++ __result; })) ++#endif ++ + #ifdef __cplusplus + }; + #endif