#!/bin/sh
#---------------------------------------------
#   xdg-settings
#
#   Utility script to get various settings from the desktop environment.
#
#   Refer to the usage() function below for usage.
#
#   Copyright 2009, Google Inc.
#
#   LICENSE:
#
#---------------------------------------------

manualpage()
{
cat << _MANUALPAGE
_MANUALPAGE
}

usage()
{
cat << _USAGE
_USAGE
}

#@xdg-utils-common@

check_desktop_filename()
{
    case "$1" in
      */*)
        exit_failure_syntax "invalid application name"
        ;;
      *.desktop)
        return
        ;;
      *)
        exit_failure_syntax "invalid application name"
        ;;
    esac
}

# {{{ default browser

# In order to remove an application from the automatically-generated list of
# applications for handling a given MIME type, the desktop environment may copy
# the global .desktop file into the user's .local directory, and remove that
# MIME type from its list. In that case, we must restore the MIME type to the
# application's list of MIME types before we can set it as the default for that
# MIME type. (We can't just delete the local version, since the user may have
# made other changes to it as well. So, tweak the existing file.)
# This function is hard-coded for text/html but it could be adapted if needed.
fix_local_desktop_file()
{
    apps="${XDG_DATA_HOME:-$HOME/.local/share}/applications"
    # No local desktop file?
    [ ! -f "$apps/$1" ] && return
    MIME="`grep ^MimeType= "$apps/$1" | cut -d= -f 2-`"
    case "$MIME" in
      text/html\;*|*\;text/html\;*|*\;text/html\;|*\;text/html)
        # Already has text/html? Great!
        return 0
        ;;
    esac

    # Add text/html to the list
    temp="`mktemp "$apps/$1.XXXXXX"`" || return
    grep -v ^MimeType= "$apps/$1" >> "$temp"
    echo "MimeType=text/html;$MIME" >> "$temp"

    oldlines="`wc -l < "$apps/$1"`"
    newlines="`wc -l < "$temp"`"
    # The new file should have at least as many lines as the old
    if [ $oldlines -le $newlines ]; then
        mv "$temp" "$apps/$1"
        # This can take a little bit to get noticed
        sleep 4
    else
        rm -f "$temp"
        return 1
    fi
}

xdg_mime_fixup()
{
    # xdg-mime may use ktradertest, which will fork off a copy of kdeinit if
    # one does not already exist. It will exit after about 15 seconds if no
    # further processes need it around. But since it does not close its stdout,
    # the shell (via grep) will wait around for kdeinit to exit. If we start a
    # copy here, that copy will be used in xdg-mime and we will avoid waiting.
    if [ "$DE" = kde -a -z "$XDG_MIME_FIXED" ]; then
        ktradertest text/html Application > /dev/null 2>&1
        # Only do this once, as we only need it once.
        XDG_MIME_FIXED=yes
    fi
}

get_browser_mime()
{
    xdg_mime_fixup
    xdg-mime query default text/html
}

set_browser_mime()
{
    xdg_mime_fixup
    orig="`get_browser_mime`"
    # Fixing the local desktop file can actually change the default browser all
    # by itself, so we fix it only after querying to find the current default
    fix_local_desktop_file "$1" || return
    mkdir -p "${XDG_DATA_HOME:-$HOME/.local/share}/applications"
    xdg-mime default "$1" text/html || return
    if [ x"`get_browser_mime`" != x"$1" ]; then
        # Put back the original value
        xdg-mime default "$orig" text/html
        exit_failure_operation_failed
    fi
}

parse_binary_or_desktop()
{
    binary="`echo "$binary" | first_word`"
    desktop="`binary_to_desktop_file "$binary"`"
    if [ "$desktop" ]; then
        basename "$desktop"
        exit_success
    fi
    binary="`which "$binary"`"
    if [ "$binary" ]; then
        echo "$binary"
        exit_success
    fi
    exit_failure_operation_failed
}

resolve_kde_browser()
{
    echo "$browser" | grep -q '^!'
    if [ $? -ne 0 ]; then
        echo "$browser"
    else
        binary="${browser#!}"
        parse_binary_or_desktop
    fi
}

get_browser_kde()
{
    browser="`kreadconfig --file kdeglobals --group General --key BrowserApplication`"
    if [ x"$browser" = x ]; then
        # No explicit default browser; KDE will use the MIME type text/html
        get_browser_mime
    else
        resolve_kde_browser
    fi
}

check_browser_kde()
{
    browser="`kreadconfig --file kdeglobals --group General --key BrowserApplication`"
    browser="`resolve_kde_browser`"
    # Because KDE will use the handler for MIME type text/html if this value
    # is empty, we allow either the empty string or a match to $1 here
    if [ x"$browser" != x -a x"$browser" != x"$1" ]; then
        echo no
        exit_success
    fi
    browser="`get_browser_mime`"
    if [ x"$browser" != x"$1" ]; then
        echo no
        exit_success
    fi
    echo yes
    exit_success
}

set_browser_kde()
{
    set_browser_mime "$1" || return
    kwriteconfig --file kdeglobals --group General --key BrowserApplication "$1"
}

# This handles backslashes but not quote marks
first_word()
{
    read first rest
    echo "$first"
}

binary_to_desktop_file()
{
    search="${XDG_DATA_HOME:-$HOME/.local/share}:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
    binary="`which "$1"`"
    base="`basename "$1"`"
    IFS=:
    for dir in $search; do
        unset IFS
        [ "$dir" -a -d "$dir/applications" ] || continue
        for file in "$dir"/applications/*.desktop; do
            [ -r "$file" ] || continue
            # Check to make sure it's worth the processing
            grep -q "^Exec.*$base" "$file" || continue
            command="`grep "^Exec\(\[[^]=]*]\)\?=" "$file" | cut -d= -f 2- | first_word`"
            full="`which "$command"`"
            if [ x"$full" = x"$binary" ]; then
                # Fix any double slashes that got added path composition
                echo "$file" | sed -e 's,//*,/,g'
                return
            fi
        done
    done
}

desktop_file_to_command()
{
    search="${XDG_DATA_HOME:-$HOME/.local/share}:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
    desktop="`basename "$1"`"
    IFS=:
    for dir in $search; do
        unset IFS
        [ "$dir" -a -d "$dir/applications" ] || continue
        file="$dir/applications/$desktop"
        [ -r "$file" ] || continue
        # Change %F, %f, %U, and %u to %s
        grep "^Exec\(\[[^]=]*]\)\?=" "$file" | cut -d= -f 2- | sed -e 's/%[FfUu]/%s/g'
        return
    done
}

get_browser_gnome()
{
    binary="`gconftool-2 --get /desktop/gnome/applications/browser/exec`"
    if [ x"$binary" = x ]; then
        # No default browser; GNOME might use the MIME type text/html
        get_browser_mime
    else
        # gconftool gives the binary (maybe with %s etc. afterward),
        # but we want the desktop file name, not the binary. So, we
        # have to find the desktop file to which it corresponds.
        parse_binary_or_desktop
    fi
}

check_browser_gnome()
{
    binary="`gconftool-2 --get /desktop/gnome/applications/browser/exec`"
    browser="`parse_binary_or_desktop`"
    if [ x"$browser" != x"$1" ]; then
        echo no
        exit_success
    fi
    # Check HTTP and HTTPS, but not about: and unknown:
    for protocol in http https; do
        binary="`gconftool-2 --get /desktop/gnome/url-handlers/$protocol/command | first_word`"
        browser="`parse_binary_or_desktop`"
        if [ x"$browser" != x"$1" ]; then
            echo no
            exit_success
        fi
    done
    browser="`get_browser_mime`"
    if [ x"$browser" != x"$1" ]; then
        echo no
        exit_success
    fi
    echo yes
    exit_success
}

set_browser_gnome()
{
    command="`desktop_file_to_command "$1"`"
    [ "$command" ] || exit_failure_file_missing
    binary="`echo "$command" | first_word`"
    set_browser_mime "$1" || return

    # Set the default browser
    gconftool-2 --type string --set /desktop/gnome/applications/browser/exec "$binary"
    gconftool-2 --type bool --set /desktop/gnome/applications/browser/needs_term false
    gconftool-2 --type bool --set /desktop/gnome/applications/browser/nremote true
    # Set the handler for HTTP and HTTPS
    for protocol in http https; do
        gconftool-2 --type string --set /desktop/gnome/url-handlers/$protocol/command "$command"
        gconftool-2 --type bool --set /desktop/gnome/url-handlers/$protocol/needs_terminal false
        gconftool-2 --type bool --set /desktop/gnome/url-handlers/$protocol/enabled true
    done
    # Set the handler for about: and unknown URL types
    for protocol in about unknown; do
        gconftool-2 --type string --set /desktop/gnome/url-handlers/$protocol/command "$command"
    done
}

get_browser_xfce()
{
    search="${XDG_CONFIG_HOME:-$HOME/.config}:${XDG_CONFIG_DIRS:-/etc/xdg}"
    IFS=:
    for dir in $search; do
        unset IFS
        [ "$dir" -a -d "$dir/xfce4" ] || continue
        file="$dir/xfce4/helpers.rc"
        [ -r "$file" ] || continue
        grep -q "^WebBrowser=" "$file" || continue
        desktop="`grep "^WebBrowser=" "$file" | cut -d= -f 2-`"
        echo "$desktop.desktop"
        return
    done
    exit_failure_operation_failed
}

check_browser_xfce()
{
    browser="`get_browser_xfce`"
    if [ x"$browser" != x"$1" ]; then
        echo no
        exit_success
    fi
    echo yes
    exit_success
}

check_xfce_desktop_file()
{
    # Annoyingly, xfce wants its .desktop files in a separate directory instead
    # of the standard locations, and requires a few custom tweaks to them:
    # "Type" must be "X-XFCE-Helper"
    # "X-XFCE-Category" must be "WebBrowser" (for web browsers, anyway)
    # "X-XFCE-Commands" and "X-XFCE-CommandsWithParameter" must be set
    search="${XDG_DATA_HOME:-$HOME/.local/share}:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
    IFS=:
    for dir in $search; do
        unset IFS
        [ "$dir" -a -d "$dir/xfce4/helpers" ] || continue
        file="$dir/xfce4/helpers/$1"
        # We have the file, no need to create it
        [ -r "$file" ] && return
    done
    IFS=:
    for dir in $search; do
        unset IFS
        [ "$dir" -a -d "$dir/applications" ] || continue
        file="$dir/applications/$1"
        if [ -r "$file" ]; then
            # Found a file to convert
            target="${XDG_DATA_HOME:-$HOME/.local/share}/xfce4/helpers"
            mkdir -p "$target"
            grep -v "^Type=" "$file" > "$target/$1"
            echo "Type=X-XFCE-Helper" >> "$target/$1"
            echo "X-XFCE-Category=WebBrowser" >> "$target/$1"
            # Change %F, %f, %U, and %u to "%s"
            command="`grep "^Exec\(\[[^]=]*]\)\?=" "$file" | cut -d= -f 2- | sed -e 's/%[FfUu]/"%s"/g'`"
            echo "X-XFCE-Commands=`echo "$command" | first_word`" >> "$target/$1"
            echo "X-XFCE-CommandsWithParameter=$command" >> "$target/$1"
            return
        fi
    done
    return 1
}

set_browser_xfce()
{
    check_xfce_desktop_file "$1" || exit_failure_operation_failed

    helper_dir="${XDG_CONFIG_HOME:-$HOME/.config}/xfce4"
    if [ ! -d "$helper_dir" ]; then
        mkdir -p "$helper_dir" || exit_failure_operation_failed
    fi

    helpers_rc="$helper_dir/helpers.rc"
    # Create the file if it does not exist to avoid special cases below
    if [ ! -r "$helpers_rc" ]; then
        touch "$helpers_rc" || exit_failure_operation_failed
    fi

    temp="`mktemp "$helpers_rc.XXXXXX"`" || return
    grep -v ^WebBrowser= "$helpers_rc" >> "$temp"
    echo "WebBrowser=${1%.desktop}" >> "$temp"

    oldlines="`wc -l < "$helpers_rc"`"
    newlines="`wc -l < "$temp"`"
    # The new file should have at least as many lines as the old
    if [ $oldlines -le $newlines ]; then
        mv "$temp" "$helpers_rc"
    else
        rm -f "$temp"
        return 1
    fi
}

# }}} default browser

dispatch_specific()
{
    # The PARM comments in this function are used to generate the output of
    # the --list option. The formatting is important. Make sure to line up the
    # property descriptions with spaces so that it will look nice.
    if [ x"$op" = x"get" ]; then
        case "$parm" in
          default-web-browser) # PROP:           Default web browser
            get_browser_$DE
            ;;

          *)
            exit_failure_syntax
            ;;
        esac
    elif [ x"$op" = x"check" ]; then
        case "$parm" in
          default-web-browser)
            check_desktop_filename "$1"
            check_browser_$DE "$1"
            ;;

          *)
            exit_failure_syntax
            ;;
        esac
    else # set
        [ $# -eq 1 ] || exit_failure_syntax "unexpected/missing argument"
        case "$parm" in
          default-web-browser)
            check_desktop_filename "$1"
            set_browser_$DE "$1"
            ;;

          *)
            exit_failure_syntax
            ;;
        esac
    fi

    if [ $? -eq 0 ]; then
        exit_success
    else
        exit_failure_operation_failed
    fi
}

dispatch_generic()
{
    # We only know how to get the default web browser
    [ x"$op" != x"get" ] && exit_failure_operation_impossible
    [ x"$parm" != x"default-web-browser" ] && exit_failure_operation_impossible

    # FIXME: look up the desktop file name

    # First look in $BROWSER
    if [ x"$BROWSER" != x ]; then
        echo "${BROWSER%%:*}"
        exit_success
    fi

    # Debian and Ubuntu (and others?) have x-www-browser
    browser="`which x-www-browser`"
    [ "$browser" ] || exit_failure_operation_failed
    browser="`readlink -f "$browser"`"

    echo "$browser"
    exit_success
}

if [ x"$1" = x"--list" ]; then
    echo "Known properties:"
    # Extract the property names from dispatch_specific() above
    grep "^[ 	]*[^)]*) # PROP:" "$0" | sed -e 's/^[ 	]*\([^)]*\)) # PROP: \(.*\)$/  \1 \2/' | sort
    exit_success
fi

[ x"$1" != x ] || exit_failure_syntax "no operation given"
[ x"$2" != x ] || exit_failure_syntax "no parameter name given"
[ x"$1" = x"get" -o x"$3" != x ] || exit_failure_syntax "no parameter value given"

op="$1"
parm="$2"
shift 2

if [ x"$op" != x"get" -a x"$op" != x"check" -a x"$op" != x"set" ]; then
  exit_failure_syntax "invalid operation"
fi

detectDE

case "$DE" in
    kde|gnome|xfce)
    dispatch_specific "$@"
    ;;

    generic)
    dispatch_generic "$@"
    ;;

    *)
    exit_failure_operation_impossible "unknown desktop environment"
    ;;
esac
