diff --git a/extras/gtomb/LICENSE b/extras/gtomb/LICENSE
index 487c8d4..33bf5c1 100644
--- a/extras/gtomb/LICENSE
+++ b/extras/gtomb/LICENSE
@@ -1,11 +1,12 @@
 gtomb - A GUI wrapper for Tomb, the crypto undertaker
-Copyright (C) 2015 Parazyd <parazyd AT dyne DOT org>
+Copyright (C) 2015-2016 Parazyd <parazyd@dyne.org>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
+
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
diff --git a/extras/gtomb/README.md b/extras/gtomb/README.md
index 179f41a..5ce7724 100644
--- a/extras/gtomb/README.md
+++ b/extras/gtomb/README.md
@@ -11,7 +11,7 @@ list and the script will run it for you. Easy-peasy.
 
 ### Random notes
 * If you type in your sudo password once correctly, in the next 5 (or whatever your sudoers timeout is) minutes, you can type in the wrong password as well.
-* The function for catching cancellation sometimes fails because of bad ps syntax. No idea why yet.
+* The function for catching cancellation sometimes fails because of bad ps syntax. (Possibly fixed, needs more testing)
 
 ## Dependencies
 * [tomb](https://github.com/dyne/Tomb) (also get tomb's dependencies)
@@ -19,8 +19,8 @@ list and the script will run it for you. Easy-peasy.
 
 ## TODO
 * Complete error checking
-* Figure out why ps fails sometimes
 * and more stuff 
 
 ## What you need to do
 * Be patient or help with coding :)
+* Request features
diff --git a/extras/gtomb/gtomb b/extras/gtomb/gtomb
index 7cb203a..e740e28 100755
--- a/extras/gtomb/gtomb
+++ b/extras/gtomb/gtomb
@@ -1,43 +1,32 @@
 #!/usr/bin/env zsh
 #
-# gtomb - a GUI wrapper for Tomb 
-# 
-# Maintained and written by parazyd <parazyd AT dyne DOT org>
-# https://github.com/parazyd/gtomb
-# https://github.com/dyne/Tomb
+# Copyright (c) 2015-2016 parazyd
+# gtomb is written and maintained by parazyd <parazyd@dyne.org>
 #
-# gtomb is experimental software. It still does not work completely as 
-# intended and should be used with caution.
+# This file is part of gtomb
 #
-# {{{ License
-# gtomb - A GUI wrapper for Tomb, the crypto undertaker
-# Copyright (C) 2015 Parazyd <parazyd AT dyne DOT org>
-#
-# This program is free software: you can redistribute it and/or modify
+# This source code is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
-# This program is distributed in the hope that it will be useful,
+# This software is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with this program. If not, see http://www.gnu.org/licenses/
-#
-# }}}
+# along with this source code. If not, see <http://www.gnu.org/licenses/>.
 
-#set -x
-#set -v
-ver="0.6.2"
-TOMBPATH="/usr/bin/tomb" # Set this to your tomb executable's path
-KDFPATH="/usr/bin/" # Set this to the path of your KDF binaries (if you're using them)
+ver="0.8"
+TOMBPATH="/usr/local/bin/tomb" # Set this to your tomb executable's path
+KDFPATH="/usr/local/bin/" # Set this to the path of your KDF binaries (if you're using them)
 # The ones below should not need changing
 HEXENC="$KDFPATH/tomb-kdb-hexencode"
 GENSALT="$KDFPATH/tomb-kdb-pbkdf2-gensalt"
 GETITER="$KDFPATH/tomb-kdb-pbkdf2-getiter"
 PBKDF="$KDFPATH/tomb-kdb-pbkdf2"
+_DD=/bin/dd
 
 # {{{ monmort icon
 MONMORT="/tmp/monmort.png"
@@ -52,15 +41,19 @@ b2RpZnkAMjAxMS0wMS0xMlQwOTozNDoyNCswMTowMNKiZVMAAAAASUVORK5CYII="
 echo -e "$ICONB64" | base64 --decode > $MONMORT
 # }}}
 
-function _ { _clean } # I like cleaning :)
+# {{{ sudo functions
+function _sudo {
+    sudoassword=$(ask_password "Insert sudo password for user $USER")
+    echo -e "$sudoassword\n" | sudo -S -v
+    _sudowrong
+}
 
-# {{{ sudo function
 function _sudowrong {
-    if [[ $? == 1 ]]; then
+    [[ $? = 0 ]] || {
         sudoassword=$(ask_password "Wrong password. Insert sudo password for user $USER")
         echo -e "$sudoassword\n" | sudo -S -v
         _sudowrong
-    fi
+    }
 }
 # }}}
 
@@ -71,7 +64,6 @@ function _zenques {
         --question \
         --text="$1"
 }
-
 function _fsel {
     zenity \
         --window-icon="$MONMORT" \
@@ -93,6 +85,21 @@ function _zenwarn {
         --title="$1" \
         --text="$2"
 }
+function _info {
+    which notify-send > /dev/null
+    if [[ $? == "0" ]]; then
+        _zenotif $*
+    else
+        _zeninfo $*
+    fi
+}
+function _zenotif {
+    zenity \
+        --window-icon="$MONMORT" \
+        --notification \
+        --title="$1" \
+        --text="$2"
+}
 function _zeninfo {
     zenity \
         --window-icon="$MONMORT" \
@@ -141,7 +148,6 @@ function _zenentry {
 # Wraps around the pinentry command, from the GnuPG project, as it
 # provides better security and conveniently use the right toolkit.
 ask_password() {
-
     local description="$1"
     local title="${2:-Enter tomb password.}"
     local output
@@ -299,22 +305,19 @@ function _failure die() {
 
 # {{{ _clean - Clean function, removes sensitive stuff from memory
 function _clean {
-    
-    echo "Cleaning..." # For debugging.
     unset $?
     local rr="$RANDOM"
     while [[ ${#rr} -lt 500 ]]; do
         rr+="$RANDOM"
     done
 
-    command="$rr";      unset command
+    cmnd="$rr";         unset cmnd
     tombname="$rr";     unset tombname
     tombsize="$rr";     unset tombsize
     keyfile="$rr";      unset keyfile
     sudoassword="$rr";  unset sudoassword
-    tombtmp=/tmp/tombtmp
-    if [ -f $tombtmp ]
-    then
+    tombtmp="/tmp/tombtmp"
+    if [ -f $tombtmp ]; then
         dd if=/dev/urandom of=$tombtmp bs=800 count=1
         rm -f $tombtmp
     fi
@@ -327,7 +330,7 @@ function _clean {
 # {{{ _main - Main window
 function _main {
     _clean
-    command=`zenity \
+    cmnd=`zenity \
         --window-icon="$MONMORT" \
         --title="gtomb" \
         --width=640 \
@@ -353,222 +356,157 @@ function _main {
         "engrave" "Generates a QR code of a key to be saved on paper" \
         "bury" "Hide a key inside a JPEG image" \
         "exhume" "Extract a key from a JPEG image"`
-
-    eval "_$command"
+    eval "_$cmnd"
 }
 # }}}
 
 # {{{ dig - Dig a new tomb
 function _dig {
-
     tombname=`_fsave "Choose where to dig your tomb" "secret.tomb"`
-
     res=$?
 
-    if [[ -f $tombname ]]; then
+    if [[ -f "$tombname" ]]; then
         _zenerr "Error" "This tomb already exists. I am not digging here."
         exec _main
-    elif [[ $tombname == "" ]]; then
-        _zenwarn "Warning" "Try again."
+    elif [[ -z "$tombname" ]]; then
+        _info "gtomb" "Cancelled"
         exec _main
     fi
 
-    case $res in
-        0)
-            tombsize=`_zenentry "Tomb digging" "Enter the size of your tomb in MiB (min. 10 MiB)" "10"`
+	[[ $res = 0 ]] || exec _main
 
-            res=$?
+	tombsize=`_zenentry "Tomb digging" "Enter the size of your tomb in MiB (min. 10 MiB)" "10"`
+	res=$?
 
-            re='^[0-9]+$'
-            if ! [[ $tombsize =~ $re ]]; then
-                _zenerr "Error" "Please choose a valid number."
-                exec _main
-            elif [[ $tombsize == "" ]]; then
-                _zenwarn "Warning" "Try again."
-                exec _main
-            fi
+	re='^[0-9]+$'
+	if ! [[ $tombsize =~ $re ]]; then
+		_zenerr "Error" "Please choose a valid number."
+		exec _main
+	elif [[ -z $tombsize ]]; then
+		_info "gtomb" "Cancelled"
+		exec _main
+	fi
 
-            case $res in
-                0)
-                    $TOMBPATH dig -s $tombsize $tombname | \
-                        _zenprog "Digging new tomb" "Please wait while your tomb is being dug..." &
+	[[ $res = 0 ]] || { _zenwarn "Warning" "Tomb digging canceled." ; exec _main }
 
-                    PID_ZEN=$(ps -C zenity h -o pid,command | grep "Digging new tomb" | awk '{print $1}')
+	"$TOMBPATH" dig -s "$tombsize" "$tombname" | \
+		_zenprog "Digging new tomb" "Please wait while your tomb is being dug..." &
 
-                    while [ "$PID_ZEN" != "" ]; do
-                        PID_ZEN=$(ps h -o pid -p ${PID_ZEN})
-                        PID_DD=$(ps -C dd h -o pid,command | grep "$tombname" | awk '{print $1}')
-                        sleep 1
-                    done
+	PID_ZEN=$(ps -C zenity h -o pid,command | awk '/Digging new tomb/ {print $1}')
+	while [ -n "$PID_ZEN" ]; do
+		PID_ZEN=$(ps h -o pid -p ${PID_ZEN})
+		PID_DD=$(ps -C $_DD h -o pid,command | awk -v tombtmp="$tombname" '$0~tombtmp{print $1}')
+		sleep 1
+	done
 
-                    if [[ "$PID_DD" != "" && "$PID_ZEN" == "" ]]; then
-                        kill -9 $PID_DD
-                        _zenwarn "Warning" "Tomb digging canceled."
-                        rm -f $tombname
-                        exec _main
-                    fi
+	[[ -n "$PID_DD" && -z "$PID_ZEN" ]] && {
+		kill -9 $PID_DD
+		_zenwarn "Warning" "Tomb digging cancelled."
+		rm -f "$tombname"
+		exec _main
+	}
 
-                    _clean
-                    _zeninfo "Success" "Your tomb has been dug."
-                    exec _main
-                    ;;
-                1)
-                    _zenwarn "Warning" "Tomb digging canceled."
-                    exec _main
-                    ;;
-            1)
-                exec _main
-                ;;
-            esac
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	_info "Success" "Your tomb has been dug in $tombname"
+	exec _main
 }
 # }}}
 
 # {{{ forge - Forge a new key
 function _forge {
     keyfile=`_fsave "Choose where to forge your key" "secret.tomb.key"`
-    
     res=$?
 
     if [[ -f $keyfile ]]; then
         _zenerr "Error" "This key already exists. I am not overwriting."
         exec _main
-    elif [[ $keyfile == "" ]]; then
-        _zenwarn "Warning" "Try again."
+    elif [[ -z $keyfile ]]; then
+        _info "gtomb" "Canceled"
         exec _main
     fi
 
-    if [[ -f $HEXENC ]] && [[ -f $GENSALT ]] && [[ -f $GETITER ]] && [[ -f $PBKDF ]]; then
-        kdf=""
-        kdfiter=""
-        _zenques "Do you want to use KDF? (Generates passwords armored against dictionary attacks)" 
-        if [[ $? == "0" ]]; then
+    kdf=""
+    kdfiter=""
+    if [[ -x $HEXENC ]] && [[ -x $GENSALT ]] && [[ -x $GETITER ]] && [[ -x $PBKDF ]]; then
+        _zenques "Do you want to use KDF? (Generates passwords armored against dictionary attacks)"
+        [[ $? == "0" ]] && {
             kdf="--kdf"
-            kdfiter=`_zenentry "Iterations" "Enter the delay (itertime) in seconds for each time this key is used:" "2"`
-        fi
-    fi
+            kdfiter=`_zenentry "Iterations" "Enter the delay (itertime) in seconds for each time \n\
+this key is used:" "2"`
 
-    case $res in
-        0)
-            $TOMBPATH forge $keyfile $kdf $kdfiter | \
-                _zenprog "Forging key" "Please wait while your key is being forged...\n\
-You can move your mouse around and use your computer to speed up the process." &
-
-            PID_ZEN=$(ps -C zenity h -o pid,command | grep "Forging key" | awk '{print $1}')
-
-            while [ "$PID_ZEN" != "" ]; do
-                PID_ZEN=$(ps h -o pid -p ${PID_ZEN})
-                PID_DD=$(ps -C dd h -o pid,command | grep " if=" | awk '{print $1}')
-                sleep 1
-            done
-
-            if [[ "$PID_DD" != "" && "$PID_ZEN" == "" ]]; then
-                kill -9 $PID_DD
-                _zenwarn "Warning" "Forging canceled."
-                rm -f $keyfile
+            re='^[0-9]+$'
+            if ! [[ $kdfiter =~ $re ]]; then
+                _zenerr "Error" "Please choose a valid number."
+                exec _main
+            elif [[ -z $kdfiter ]]; then
+                _info "gtomb" "Canceled"
                 exec _main
             fi
+        }
+    else
+        _zenotif "gtomb" "KDF binaries not found."
+    fi
 
-            _clean
-            _zeninfo "Success" "Your key is now forged."
-            exec _main
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	[[ $? = 0 ]] || exec _main
+
+	"$TOMBPATH" forge "$keyfile" "$kdf" "$kdfiter" | \
+		_zenprog "Forging key" "Please wait while your key is being forged...\n\
+You can move your mouse around and use your computer to speed up the process." &
+
+	PID_ZEN=$(ps -C zenity h -o pid,command | awk '/Forging key/ {print $1}')
+	while [ -n "$PID_ZEN" ]; do
+		PID_ZEN=$(ps h -o pid -p ${PID_ZEN})
+		PID_DD=$(ps -C $_DD h -o pid,command | awk '/ if/ {print $1}')
+		sleep 1
+	done
+	[[ -n "$PID_DD"  && -z "$PID_ZEN" ]] && {
+		kill -9 $PID_DD
+		_zenwarn "Warning" "Forging cancelled."
+		rm -f $keyfile
+		exec _main
+	}
+
+	_info "Success" "Your key is now forged in $keyfile"
+	exec _main
 }
 # }}}
 
 # {{{ lock - Lock a non-locked tomb
 function _lock {
     tombname=`_fsel "Select a tomb to lock"`
+    [[ -n $tombname ]] || { _zenotif "gtomb" "Cancelled" ; exec _main }
+	[[ $? = 0 ]] || exec _main
 
-    res=$?
-    
-    if [[ $tombname == "" ]]; then
-        _zenwarn "Warning" "Try again."
-        exec _main
-    fi
-    
-    case $res in
-        0)
-            keyfile=`_fsel "Choose the key for your tomb"`
+	keyfile=`_fsel "Choose the key for your tomb"`
+	[[ -n $keyfile ]] || { _zenotif "gtomb" "Cancelled" ; exec _main }
+	[[ $? = 0 ]] || exec _main
 
-            res=$?
-
-            if [[ $keyfile == "" ]]; then
-                _zenwarn "Warning" "Try again."
-                exec _main
-            fi
-
-            case $res in
-                0)  
-                    sudoassword=$(ask_password "Insert sudo password for user $USER")
-                    echo -e "$sudoassword\n" | sudo -S -v
-                    _sudowrong
-
-                    $TOMBPATH lock $tombname -k $keyfile | \
-                        _zenprognc "Locking your tomb" "Please wait while your tomb is being locked..."
-                    
-                    _clean # Clean sensitive stuff from memory
-                    _zeninfo "Success" "Your tomb is now locked."
-                    exec _main
-                    ;;
-                1)
-                    exec _main
-                    ;;
-            esac
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	_sudo
+	"$TOMBPATH" lock "$tombname" -k "$keyfile" | \
+		_zenprognc "Locking your tomb" "Please wait while your tomb is being locked..."
+	_info "Success" "Your tomb is now locked."
+	exec _main
 }
 # }}}
 
 # {{{ open - Open an existing tomb
 function _open {
     tombname=`_fsel "Choose a tomb to open"`
+	[[ $? = 0 ]] || exec _main
 
-    res=$?
-    case $res in
-        0)
-            keyfile=`_fsel "Choose the key for your tomb"`
+	keyfile=`_fsel "Choose the key for your tomb"`
+	[[ $? = 0 ]] || exec _main
 
-            res=$?
-            case $res in
-                0)
-                    sudoassword=$(ask_password "Insert sudo password for user $USER")
-                    echo -e "$sudoassword\n" | sudo -S -v
-                    _sudowrong
-
-                    $TOMBPATH open $tombname -k $keyfile
-
-                    _clean # Clean sensitive stuff from memory
-                    _zeninfo "Success" "Your tomb is now open."
-                    exec _main
-                    ;;
-                1)
-                    exec _main
-                    ;;
-            esac
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	_sudo
+	"$TOMBPATH" open "$tombname" -k "$keyfile"
+	_info "Success" "Your tomb is now open."
+	exec _main
 }
 # }}}
 
 # {{{ list - list all open tombs, along with their mountpoint
 function _list {
     tombtmp="/tmp/tombtmp"
-    $TOMBPATH list --get-mountpoint > $tombtmp
+    "$TOMBPATH" list --get-mountpoint > $tombtmp
     tombname=`cat $tombtmp | \
         sed 's/.*\/\([^\/]*\)$/\1\n &/' | \
         zenity \
@@ -580,98 +518,85 @@ function _list {
             --column=Tomb \
             --column=Path `
 
-    res=$?
-    case $res in
-        0)
-            listchoice=`zenity \
-                --title="Choose action" \
-                --window-icon="$MONMORT" \
-                --width=640 --height=400 --list \
-                --separator=" & " \
-                --text="What do you want to do with this tomb?" \
-                --column=Command \
-                --column=Description \
-                "disindex" "Disable indexing of this tomb." \
-                "enindex" "Enable indexing of this tomb."   \
-                "close" "Close the selected tomb." \
-                "slam" "Slam the selected tomb." \
-                "binds" "Edit current bind-hooks." \
-                "posts" "Edit current post-hooks."`
+    tombname=`echo "$tombname" | cut -c1-16`
 
-            if [[ $? == 1 ]]; then
-                exec _main
-            fi
+	[[ $? = 0 ]] || exec _main
 
-            case $listchoice in
-                close)
-                    sudoassword=$(ask_password "Insert sudo password for user $USER") 
-                    echo -e "$sudoassword\n" | sudo -S -v
-                    _sudowrong
+	listchoice=`zenity \
+		--title="Choose action" \
+		--window-icon="$MONMORT" \
+		--width=640 --height=400 --list \
+		--separator=" & " \
+		--text="What do you want to do with this tomb?" \
+		--column=Command \
+		--column=Description \
+		"disindex" "Disable indexing of this tomb." \
+		"enindex" "Enable indexing of this tomb."   \
+		"close" "Close the selected tomb." \
+		"slam" "Slam the selected tomb." \
+		"binds" "Edit current bind-hooks." \
+		"posts" "Edit current post-hooks."`
 
-                    $TOMBPATH close $tombname
-                    _zeninfo "Success" "Tomb closed successfully!"
-                    exec _main
-                    ;;
-                slam)
-                    sudoassword=$(ask_password "Insert sudo password for user $USER") 
-                    echo -e "$sudoassword\n" | sudo -S -v
-                    _sudowrong
+	[[ $? = 0 ]] || exec _main
 
-                    $TOMBPATH slam $tombname
-                    _zeninfo "Success" "Tomb slammed successfully!"
-                    exec _main
-                    ;;
-                disindex)
-                    tombloc=`$TOMBPATH list $tombname --get-mountpoint`
-                    touch "$tombloc/.noindex"
-                    _zeninfo "Success" "Indexing disabled for this tomb."
-                    exec _main
-                    ;;
-                enindex)
-                    tombloc=`$TOMBPATH list $tombname --get-mountpoint`
-                    rm "$tombloc/.noindex"
-                    _zeninfo "Success" "Indexing of this tomb is enabled."
-                    exec _main
-                    ;;
-                binds)
-                    tombloc=`$TOMBPATH list $tombname --get-mountpoint` 
-                    bindhooks=`zenity \
-                        --text-info \
-                        --filename="$tombloc/bind-hooks" \
-                        --editable`
-                    if [[ $? == "0" ]]; then
-                        echo "$bindhooks" > "$tombloc/bind-hooks"
-                    fi
-                    exec _main
-                    ;;
-                posts)
-                    tombloc=`$TOMBPATH list $tombname --get-mountpoint`
-                    
-                    posthooks=`zenity \
-                        --text-info \
-                        --filename="$tombloc/post-hooks" \
-                        --editable`
-                    if [[ $? == "0" ]]; then
-                        echo "$posthooks" > "$tombloc/post-hooks"
-                        chmod +x $tombloc/post-hooks
-                    fi
-                    exec _main
-                    ;;
-  
-                # See what else to add
-            esac
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	case $listchoice in
+		close)
+			_sudo
+			"$TOMBPATH" close "$tombname"
+			_zeninfo "Success" "Tomb closed successfully!"
+			exec _main
+			;;
+		slam)
+			_sudo
+			"$TOMBPATH" slam "$tombname"
+			_info "Success" "$tombname slammed successfully!"
+			exec _main
+			;;
+		disindex)
+			tombloc=`"$TOMBPATH" list "$tombname" --get-mountpoint`
+			touch "$tombloc/.noindex"
+			_info "Success" "Indexing disabled for this tomb."
+			exec _main
+			;;
+		enindex)
+			tombloc=`"$TOMBPATH" list "$tombname" --get-mountpoint`
+			rm -f "$tombloc/.noindex"
+			_info "Success" "Indexing of this tomb is now enabled."
+			exec _main
+			;;
+		binds)
+			tombloc=`"$TOMBPATH" list "$tombname" --get-mountpoint`
+			bindhooks=`zenity \
+				--text-info \
+				--filename="$tombloc/bind-hooks" \
+				--editable`
+			[[ $? = 0 ]] && {
+				echo "$bindhooks" > "$tombloc/bind-hooks"
+				_info "gtomb" "bind-hooks saved"
+			}
+			exec _main
+			;;
+		posts)
+			tombloc=`"$TOMBPATH" list "$tombname" --get-mountpoint`
+			posthooks=`zenity \
+				--text-info \
+				--filename="$tombloc/post-hooks" \
+				--editable`
+			[[ $? = 0 ]] && {
+				echo "$posthooks" > "$tombloc/post-hooks"
+				chmod +x "$tombloc/post-hooks"
+				_info "gtomb" "post-hooks saved"
+			}
+			exec _main
+			;;
+	esac
 }
 # }}}
 
 # {{{ close - Close open tomb(s)
 function _close {
     tombtmp="/tmp/tombtmp"
-    $TOMBPATH list --get-mountpoint > $tombtmp
+    "$TOMBPATH" list --get-mountpoint > $tombtmp
     echo "/all" >> $tombtmp
     tombname=`cat $tombtmp | \
         sed 's/.*\/\([^\/]*\)$/\1\n &/' | \
@@ -683,30 +608,20 @@ function _close {
             --column=Tomb \
             --column=Path `
 
-        res=$?
-        case $res in
-            0)
-                sudoassword=$(ask_password "Insert sudo password for user $USER")
-                echo -e "$sudoassword\n" | sudo -S -v
-                _sudowrong
+	[[ $? = 0 ]] || exec _main
 
-                $TOMBPATH close $tombname
-
-                _clean # Clean sensitive stuff from memory
-                _zeninfo "Success" "Tomb(s) closed successfully!"
-                exec _main
-                ;;
-            1)
-                exec _main
-                ;;
-        esac
+	_sudo
+	tombname=`echo "$tombname" | cut -c1-16`
+	"$TOMBPATH" close "$tombname"
+	_info "Success" "Closed successfully!"
+	exec _main
 }
 # }}}
 
 # {{{ slam - Slam open tombs
 function _slam {
     tombtmp="/tmp/tombtmp"
-    $TOMBPATH list --get-mountpoint > $tombtmp
+    "$TOMBPATH" list --get-mountpoint > $tombtmp
     echo "/all" >> $tombtmp
     tombname=`cat $tombtmp | \
         sed 's/.*\/\([^\/]*\)$/\1\n &/' | \
@@ -717,238 +632,137 @@ function _slam {
             --separator=" & " \
             --column=Tomb \
             --column=Path `
-            
-    res=$?
-    case $res in
-        0)
-            sudoassword=$(ask_password "Insert sudo password for user $USER")
-            echo -e "$sudoassword\n" | sudo -S -v
-            _sudowrong
 
-            $TOMBPATH slam $tombname
+	[[ $? = 0 ]] || exec _main
 
-            _clean # Clean sensitive stuff from memory
-            _zeninfo "Success" "Tomb(s) slammed successfully!"
-            exec _main
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	_sudo
+	tombname=`echo "$tombname" | cut -c1-16`
+	"$TOMBPATH" slam "$tombname"
+	_info "Success" "Slammed successfully!"
+	exec _main
 }
 # }}}
 
 # {{{ resize - Resize an existing *closed* tomb
 function _resize {
     tombname=`_fsel "Choose a tomb to resize"`
-
     res=$?
-    case $res in
-        0)
-            tombsize=`_zenentry "New tomb size" "Enter the new size of your tomb in MiB. Must be higher than the current size." "100"`
+    _zenques "Is your tomb closed?"
 
-            res=$?
-            case $res in
-                0)
-                    keyfile=`_fsel "Choose according keyfile"`
+	[[ $? = 0 ]] || { _zenwarn "gtomb" "Please close the tomb before resizing." ; exec _main }
 
-                    res=$?
-                    case $res in
-                        0)
-                            sudoassword=$(ask_password "Insert sudo password for user $USER")
-                            echo -e "$sudoassword\n" | sudo -S -v
-                            _sudowrong
+	[[ $res = 0 ]] || exec _main
 
-                            $TOMBPATH resize $tombname -s $tombsize -k $keyfile | \
-                                _zenprognc "Resizing tomb." "Please wait while your tomb is being resized..."
+	tombsize=`_zenentry "New tomb size" "Enter the new size of your tomb in MiB. Must be higher than the current size." "100"`
+	[[ -n $tombsize ]] || _zenotif "gtomb" "Cancelled"
 
-                            _clean # Clean sensitive stuff from memory
-                            _zeninfo "Success" "Tomb resized successfully!"
-                            exec _main
-                            ;;
-                        1)
-                            exec _main
-                            ;;
-                    esac
-                    ;;
-                1)
-                    exec _main
-                    ;;
-            esac
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	re='^[0-9]+$'
+	if ! [[ $tombsize =~ $re ]]; then
+		_zenerr "Error" "Please choose a valid number."
+		exec _main
+	elif [[ -z $tombsize ]]; then
+		_info "gtomb" "Cancelled"
+		exec _main
+	fi
+
+	[[ $? = 0 ]] || exec _main
+
+	keyfile=`_fsel "Choose according keyfile"`
+	[[ $? = 0 ]] || exec _main
+
+	_sudo
+	"$TOMBPATH" resize "$tombname" -s "$tombsize" -k "$keyfile" | \
+		_zenprognc "Resizing tomb." "Please wait while your tomb is being resized..."
+	_info "Success" "Tomb resized successfully!"
+	exec _main
 }
 # }}}
 
 # {{{ passwd - Change existing key's passphrase
 function _passwd {
     keyfile=`_fsel "Choose a keyfile"`
+	[[ $? = 0 ]] || exec _main
 
-    res=$?
-    case $res in
-        0)
-            $TOMBPATH passwd -k $keyfile | \
-                _zenprognc "Changing passphrase" "Please wait while your key's passphrase is being changed..."
-            
-            _clean # Clean sensitive stuff from memory
-            _zeninfo "Success" "Passphrase changed successfully!"
-            exec _main
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	"$TOMBPATH" passwd -k "$keyfile" | \
+		_zenprognc "Changing passphrase" "Please wait while your key's passphrase is being changed..."
+
+	_info "Success" "$keyfile passphrase changed successfully!"
+	exec _main
 }
 # }}}
 
 # {{{ setkey - Change a tomb's keyfile
 function _setkey {
     tombname=`_fsel "Choose a tomb to change its keyfile"`
+	[[ $? = 0 ]] || exec _main
 
-    res=$?
-    case $res in
-        0)
-            keyfile=`_fsel "Chosse your tomb's old keyfile"`
+	keyfile=`_fsel "Chosse your tomb's old keyfile"`
+	 [[ $? = 0 ]] || exec _main
 
-            res=$?
-            case $res in
-                0)
-                    newkey=`_fsel "Choose your tomb's new keyfile"`
+	newkey=`_fsel "Choose your tomb's new keyfile"`
+	[[ $? = 0 ]] || exec _main
 
-                    res=$?
-                    case $res in
-                        0)
-                            sudoassword=$(ask_password "Insert sudo password for $USER")
-                            echo -e "$sudoassword\n" | sudo -S -v
-                            _sudowrong
+	_sudo
+    "$TOMBPATH" setkey -k "$newkey" "$keyfile" "$tombname" | \
+		_zenprognc "Changing key" "Please wait while your tomb's key is being changed..."
 
-                            $TOMBPATH setkey -k $newkey $keyfile $tombname | \
-                                _zenprognc "Changing key" "Please wait while your tomb's key is being changed..."
-
-                            _clean
-                            _zeninfo "Success" "Tomb's keyfile successfully changed!"
-                            exec _main
-                            ;;
-                        1)
-                            exec _main
-                            ;;
-                    esac
-                    ;;
-                1)
-                    exec _main
-                    ;;
-            esac
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	_info "Success" "$tombname keyfile successfully changed! Now using $newkey"
+    exec _main
 }
 # }}}
 
 # {{{ engrave - generate QR code of a key
 function _engrave {
-    which qrencode || _zenwarn "Warning" "qrencode is not installed. Install it and try again" && exec _main
+    which qrencode || _zenwarn "Warning" "qrencode is not installed. Install it and try again"
     keyfile=`_fsel "Choose a keyfile to engrave"`
+	[[ $? = 0 ]] || exec _main
 
-    res=$?
-    case $res in
-        0)
-            jpegfile=`_fsave "Choose where to save your keyfile (PNG format)"`
-            
-            res=$?
-            case $res in
-                0)
-                    awk '/^-----/ {next}; /^Version/ {next}; {print $0}' $keyfile \
-                        | qrencode --size 4 --level H --casesensitive -o $jpegfile
-                    
-                    _zeninfo "Success" "QR code generated in $jpegfile"
-                    exec _main
-                    ;;
-                1)
-                    exec _main
-                    ;;
-            esac
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	jpegfile=`_fsave "Choose where to save your keyfile (PNG format)"`
+	[[ $? = 0 ]] || exec _main
+
+	awk '/^-----/ {next}; /^Version/ {next}; {print $0}' $keyfile \
+		| qrencode --size 4 --level H --casesensitive -o $jpegfile
+
+	_info "Success" "QR code generated in $jpegfile"
+	exec _main
 }
 # }}}
 
 # {{{ bury - hide a keyfile in a JPEG image
 function _bury {
-    which steghide || _zenwarn "Warning" "steghide is not installed. Install it and try again" && exec _main
+    which steghide || _zenwarn "Warning" "steghide is not installed. Install it and try again"
     keyfile=`_fsel "Choose keyfile"`
+	[[ $? = 0 ]] || exec _main
 
-    res=$?
-    case $res in
-        0)
-            jpegfile=`_fsel "Choose JPEG file"`
+	jpegfile=`_fsel "Choose JPEG file"`
+	[[ $? = 0 ]] || exec _main
 
-            res=$?
-            case $res in
-                0)
-                    $TOMBPATH bury -k $keyfile $jpegfile
-
-                    _zeninfo "Success" "Your key is now hidden in $jpegfile"
-                    _clean # Clean sensitive stuff from memory
-                    exec _main
-                    ;;
-                1)
-                    exec _main
-                    ;;
-            esac
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	"$TOMBPATH" bury -k "$keyfile" "$jpegfile"
+	_info "Success" "Your key is now hidden in $jpegfile"
+	exec _main
 }
 # }}}
 
 # {{{ exhume - extract keyfile from JPEG
 function _exhume {
-    which steghide || _zenwarn "Warning" "steghide is not installed. Install it and try again" && exec _main
+    which steghide || _zenwarn "Warning" "steghide is not installed. Install it and try again"
     jpegfile=`_fsel "Choose JPEG file"`
+	[[ $? = 0 ]] || exec _main
 
-    res=$?
-    case $res in
-        0)
-            keyfile=`_fsave "Choose where to extract your key"`
+	keyfile=`_fsave "Choose where to extract your key"`
+	[[ $? = 0 ]] || exec _main
 
-            res=$?
-            case $res in
-                0)
-                    $TOMBPATH exhume -k $keyfile $jpegfile
-
-                    _zeninfo "Success" "Your keyfile is extracted to $keyfile"
-                    _clean # Clean sensitive stuff from memory
-                    exec _main
-                    ;;
-                1)
-                    exec _main
-                    ;;
-            esac
-            ;;
-        1)
-            exec _main
-            ;;
-    esac
+	"$TOMBPATH" exhume -k "$keyfile" "$jpegfile"
+	_info "Success" "Your keyfile is extracted to $keyfile"
+	exec _main
 }
 # }}}
 
 # {{{ index - index the contents of open tombs
 function _index {
-    which mlocate || _zenwarn "Warning" "mlocate is not installed. Install it and try again" && exec _main
-
-    $TOMBPATH index | _zenprognc "Indexing" "Please wait while the open tombs are being indexed..."
-    _zeninfo "Success" "Tombs indexed!"
-    
+    which locate || _zenwarn "Warning" "mlocate is not installed. Install it and try again"
+    "$TOMBPATH" index | _zenprognc "Indexing" "Please wait while the open tombs are being indexed..."
+    _info "Success" "Tombs indexed!"
     exec _main
 }
 # }}}
@@ -956,30 +770,36 @@ function _index {
 # {{{ search - searches the contents of indexed tombs
 function _search {
     strings=""
-
-    function _searchstring {
-        srchstring=`_zenentry "Search" "Enter an argument to search. Cancel to finish."`
-        res=$?
-        strings="$strings $srchstring"
-        
-        if [[ $res == "1" ]]; then
-            tombtmp="/tmp/tombtmp"
-            $TOMBPATH search $strings > $tombtmp
-            #cat $tombtmp | \
-                zenity \
-                    --text-info \
-                    --title="Search results" \
-                    --filename=$tombtmp
-        else
-            _searchstring
-        fi
-    }
     _searchstring
+    exec _main
 }
+
+function _searchstring {
+	srchstring=`_zenentry "Search" "Enter an argument to search. Cancel to finish."`
+	res=$?
+	strings="$strings $srchstring"
+
+	if [[ $res = 1 ]]; then
+		tombtmp="/tmp/tombtmp"
+		_info "Success" "Search complete!"
+		"$TOMBPATH" search "$strings" > $tombtmp
+			zenity \
+				--text-info \
+				--width=800 --height=640 \
+				--title="Search results" \
+				--filename=$tombtmp
+	else
+		_searchstring
+	fi
+}
+
+
 # }}}
 
-if [ ! -f $TOMBPATH ]; then
-    _zenwarn "Warning" "Tomb binary is nonexistent in the current path. Install it or edit the script to point to the correct path."
-else
-    _main
-fi
+function _ { _clean } # I like cleaning :)
+
+[[ -x $TOMBPATH ]] || {
+    _zenwarn "Warning" "Tomb binary is not executable or doesn't exist in the current path. Install it or edit the script to point to the correct path."
+	exit 1 }
+
+_main