← Back to branch summary

~saiarcot895/ubuntu/wily/xdg-utils/fix-multiple-execs

« back to all changes in this revision

Viewing changes to scripts/xdg-desktop-menu.in

  • Committer: Package Import Robot
  • Author(s): Per Olofsson
  • Date: 2011-12-12 12:04:25 UTC
  • mfrom: (1.2.8)
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: package-import@ubuntu.com-20111212120425-0rdnrl8tn45vz171
Tags: 1.1.0~rc1+git20111210-1
http://bugs.debian.org/648733
* New upstream git snapshot b961235b197647d6649ef3d48d7cc2cecafe3d47.
* Drop patches applied upstream:
  - xdg-mime-follow-symlinks.diff
  - x-www-browser.diff
  - xdg-mime-generic-use-mimetype.diff
  - bashisms.diff
  - xdg-screensaver-check-gnome.diff
* Modify patches to make changes to scripts/xdg-*.in, instead of the
  generated scripts.
* Also check for ~/.mutt/muttrc when deciding whether to use mutt as
  MUA or not. Thanks to martin f krafft. Closes: #648733.
* Build scripts/xdg-* from *.in files.
* Build-depend on xmlto and awk, as they are needed when building the
  scripts.
* Also build the manual pages.
* Bump Standards-Version to 3.9.2. No changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
scripts/xdg-desktop-menu.in
 
1
#!/bin/sh
 
2
#---------------------------------------------
 
3
#   xdg-desktop-menu
 
4
#
 
5
#   Utility script to install menu items on a Linux desktop.
 
6
#   Refer to the usage() function below for usage.
 
7
#
 
8
#   Copyright 2009-2010, Fathi Boudra <fabo@freedesktop.org>
 
9
#   Copyright 2009-2010, Rex Dieter <rdieter@fedoraproject.org>
 
10
#   Copyright 2006, Kevin Krammer <kevin.krammer@gmx.at>
 
11
#   Copyright 2006, Jeremy White <jwhite@codeweavers.com>
 
12
#
 
13
#   LICENSE:
 
14
#
 
15
#---------------------------------------------
 
16
 
 
17
manualpage()
 
18
{
 
19
cat << _MANUALPAGE
 
20
_MANUALPAGE
 
21
}
 
22
 
 
23
usage()
 
24
{
 
25
cat << _USAGE
 
26
_USAGE
 
27
}
 
28
 
 
29
#@xdg-utils-common@
 
30
 
 
31
update_desktop_database()
 
32
{
 
33
#    echo Update desktop database: $mode
 
34
    if [ "$mode" = "system" ] ; then
 
35
        for x in `echo $PATH | sed 's/:/ /g'` /opt/gnome/bin; do
 
36
           if [ -x $x/update-desktop-database ] ; then
 
37
              DEBUG 1 "Running $x/update-desktop-database"
 
38
              eval '$x/update-desktop-database'$xdg_redirect_output
 
39
              return
 
40
           fi
 
41
        done
 
42
    fi
 
43
}
 
44
 
 
45
# Make application $1/$2 the default for all the mimetypes it support,
 
46
# iff such mimetype didn't had a default application already.
 
47
# $1 Install dir for desktop file
 
48
# $2 base name of desktop file
 
49
make_lazy_default()
 
50
{
 
51
    local mimetypes
 
52
    local xdg_user_dir
 
53
    local xdg_default_dirs
 
54
 
 
55
    DEBUG 1 "make_lazy_default $1/$2"
 
56
    mimetypes=`awk '
 
57
{
 
58
    if (match($0,/MimeType=/)) {
 
59
        split(substr($0,RSTART+9),mimetypes,";")
 
60
        for (n in mimetypes)
 
61
        {
 
62
               if (mimetypes[n])
 
63
                 print mimetypes[n]
 
64
        }
 
65
    }
 
66
}' "$1/$2" 2> /dev/null`
 
67
 
 
68
    for MIME in $mimetypes ; do
 
69
        xdg_default_dirs="$XDG_DATA_DIRS"
 
70
        [ -n "$xdg_default_dirs" ] || xdg_default_dirs=/usr/local/share/:/usr/share/
 
71
        if [ x"$mode" = x"user" ] ; then
 
72
            xdg_user_dir="$XDG_DATA_HOME"
 
73
            [ -n "$xdg_user_dir" ] || xdg_user_dir="$HOME/.local/share"
 
74
            xdg_default_dirs="$xdg_user_dir:$xdg_default_dirs"
 
75
        fi
 
76
        local default_app
 
77
        for x in `echo "$xdg_default_dirs" | sed 's/:/ /g'`; do
 
78
            DEBUG 2 "Checking $x/applications/defaults.list"
 
79
            default_app=`grep "$MIME=" $x/applications/defaults.list 2> /dev/null | cut -d '=' -f 2`
 
80
            if [ -n "$default_app" ] ; then
 
81
                DEBUG 2 "Found default apps for $MIME: $default_app"
 
82
                default_app="$default_app;"
 
83
                break;
 
84
            fi
 
85
        done
 
86
        DEBUG 2 "Current default apps for $MIME: $default_app"
 
87
        if echo "$default_app" | grep "$2" > /dev/null 2> /dev/null; then
 
88
            # App already listed as default
 
89
            continue;
 
90
        fi
 
91
        default_file="$(readlink -f "$1/defaults.list")"
 
92
        DEBUG 1 "Updating $default_file"
 
93
        grep -v "$MIME=" $default_file > ${default_file}.new 2> /dev/null
 
94
        if ! grep "[Default Applications]" ${default_file}.new > /dev/null; then
 
95
            echo "[Default Applications]" >> ${default_file}.new
 
96
        fi
 
97
        echo $MIME="$default_app$2" >> ${default_file}.new
 
98
        mv ${default_file}.new $default_file
 
99
    done
 
100
}
 
101
 
 
102
update_submenu()
 
103
{
 
104
    DEBUG 1 "update_submenu $1"
 
105
    menu_file="$1"
 
106
 
 
107
    xdg_dir_name=menus
 
108
    xdg_user_dir="$XDG_CONFIG_HOME"
 
109
    [ -n "$xdg_user_dir" ] || xdg_user_dir="$HOME/.config"
 
110
    xdg_user_dir="$xdg_user_dir/$xdg_dir_name"
 
111
 
 
112
    xdg_system_dirs="$XDG_CONFIG_DIRS"
 
113
    [ -n "$xdg_system_dirs" ] || xdg_system_dirs=/etc/xdg
 
114
    xdg_global_dir=
 
115
    for x in `echo $xdg_system_dirs | sed 's/:/ /g'` ; do
 
116
        if [ -w $x/$xdg_dir_name ] ; then
 
117
            xdg_global_dir="$x/$xdg_dir_name"
 
118
            break
 
119
        fi
 
120
    done
 
121
    xdg_user_dir="$xdg_user_dir/applications-merged"
 
122
    xdg_global_dir="$xdg_global_dir/applications-merged"
 
123
 
 
124
    DEBUG 3 "Install locations for *.menu file:"
 
125
    DEBUG 3 "xdg_user_dir: $xdg_user_dir"
 
126
    DEBUG 3 "xdg_global_dir: $xdg_global_dir"
 
127
    DEBUG 3 "kde_user_dir: $kde_user_dir"
 
128
    DEBUG 3 "kde_global_dir: $kde_global_dir"
 
129
    DEBUG 3 "gnome_user_dir: $gnome_user_dir"
 
130
    DEBUG 3 "gnome_global_dir: $gnome_global_dir"
 
131
 
 
132
    if [ x"$mode" = x"user" ] ; then
 
133
        xdg_dir="$xdg_user_dir"
 
134
        kde_dir="$kde_user_dir"
 
135
        gnome_dir="$gnome_user_dir"
 
136
        my_umask=077
 
137
        my_chmod=0600
 
138
    else
 
139
        xdg_dir="$xdg_global_dir"
 
140
        kde_dir="$kde_global_dir"
 
141
        gnome_dir="$gnome_global_dir"
 
142
        my_umask=022
 
143
        my_chmod=0644
 
144
        if [ -z "${xdg_dir}${kde_dir}${gnome_dir}" ] ; then
 
145
            exit_failure_operation_impossible "No writable system menu directory found."
 
146
        fi
 
147
    fi
 
148
 
 
149
    if [ -z "$menu_file" ] ; then
 
150
        # Work around for SUSE/gnome 2.12 to pick up new ~/.local/share/applications
 
151
        save_umask=`umask`
 
152
        umask $my_umask
 
153
 
 
154
        mkdir -p $xdg_dir
 
155
        touch $xdg_dir/@NAME@-dummy.menu
 
156
 
 
157
        umask $save_umask
 
158
        return
 
159
    fi
 
160
 
 
161
    if [ $action = "install" ] && [ -f "/etc/xdg/menus/gnome-applications.menu" ] ; then
 
162
        # Work around for Debian Gnome
 
163
        gnome_xdg_dir=`echo "$xdg_dir" | sed -e 's^/applications-merged^/gnome-applications-merged^'`
 
164
        if [ ! -e "$gnome_xdg_dir" ] ; then
 
165
            DEBUG 1 "Debian Workaround: Link '$xdg_dir' to '$gnome_xdg_dir'"
 
166
            mkdir -p `dirname "$gnome_xdg_dir"`
 
167
            eval 'ln -s "applications-merged" "$gnome_xdg_dir"'$xdg_redirect_output
 
168
        fi
 
169
    fi
 
170
    if [ $action = "install" ] && [ -f "/etc/mandrake-release" ] ; then
 
171
        # Work around for Mandriva 2006
 
172
        mandrake_xdg_dir=`echo "$xdg_dir" | sed -e 's^/applications-merged^/applications-mdk-merged^'`
 
173
        if [ ! -e "$mandrake_xdg_dir" ] ; then
 
174
            DEBUG 1 "Mandriva Workaround: Link '$xdg_dir' to '$mandrake_xdg_dir'"
 
175
            mkdir -p `dirname "$mandrake_xdg_dir"`
 
176
            eval 'ln -s "applications-merged" "$mandrake_xdg_dir"'$xdg_redirect_output
 
177
        fi
 
178
    fi
 
179
    if [ $action = "install" -a x"$mode" = x"user" ] && [ -d "/etc/xdg/menus/kde-applications-merged" ] ; then
 
180
        # Work around for Fedora Core 5 + patched KDE
 
181
        kde_xdg_dir=`echo "$xdg_dir" | sed -e 's^/applications-merged^/kde-applications-merged^'`
 
182
        if [ ! -e "$kde_xdg_dir" ] ; then
 
183
            DEBUG 1 "Fedora Workaround: Link '$xdg_dir' to '$kde_xdg_dir'"
 
184
            mkdir -p `dirname "$kde_xdg_dir"`
 
185
            eval 'ln -s "applications-merged" "$kde_xdg_dir"'$xdg_redirect_output
 
186
        fi
 
187
    fi
 
188
    if [ $action = "install" -a x"$mode" = x"system" ] && [ -d "/etc/xdg/menus/kde-applications-merged" ] && [ ! -d "/etc/xdg/menus/applications-merged" ] ; then
 
189
        # Work around for Kubuntu 6.06
 
190
        kde_xdg_dir=`echo "$xdg_dir" | sed -e 's^/applications-merged^/kde-applications-merged^'`
 
191
        DEBUG 1 "Kubuntu Workaround: Link '$xdg_dir' to 'kde-applications-merged'"
 
192
        eval 'ln -s "kde-applications-merged" "$xdg_dir"'$xdg_redirect_output
 
193
    fi
 
194
 
 
195
    orig_menu_file=$xdg_dir/$menu_file
 
196
 
 
197
    DEBUG 1 "Updating $orig_menu_file ($action)"
 
198
 
 
199
    test "${TMPDIR+set}" = set || TMPDIR=/tmp
 
200
    tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
 
201
    orig_desktop_files=
 
202
    if [ -r "$orig_menu_file" ] ; then
 
203
        awk '
 
204
# List all files within <Filename> tags
 
205
BEGIN {
 
206
  RS="<"
 
207
}
 
208
/^Filename/ {
 
209
  if (match($0,/>/)) {
 
210
     print substr($0,RSTART+1)
 
211
  }
 
212
}' $orig_menu_file > $tmpfile
 
213
    fi
 
214
 
 
215
    orig_desktop_files=`cat $tmpfile`
 
216
    new_desktop_files=
 
217
    if [ $action = "install" ] ; then
 
218
        for desktop_file in $desktop_files; do
 
219
            basefile=`basename "$desktop_file"`
 
220
            if ! grep '^'$basefile'$' $tmpfile > /dev/null 2> /dev/null ; then
 
221
                # Append
 
222
                echo "$basefile" >> $tmpfile
 
223
            fi
 
224
        done
 
225
        new_desktop_files=`cat $tmpfile`
 
226
    fi
 
227
    if [ $action = "uninstall" ] ; then
 
228
        echo > $tmpfile
 
229
        for desktop_file in $desktop_files; do
 
230
            echo "$desktop_file" >> $tmpfile
 
231
        done
 
232
        # Files to uninstall are listed in $tmpfile
 
233
        # Existing files are in $orig_desktop_files
 
234
        for desktop_file in $orig_desktop_files; do
 
235
            if ! grep '^'$desktop_file'$' $tmpfile > /dev/null 2> /dev/null; then
 
236
                # Keep this file, it's not in the uninstall list
 
237
                new_desktop_files="$new_desktop_files $desktop_file"
 
238
            fi
 
239
        done
 
240
    fi
 
241
    rm -f "$tmpfile"
 
242
 
 
243
    DEBUG 3 "Files to list in $menu_file: $new_desktop_files"
 
244
 
 
245
    if [ -n "$new_desktop_files" ] ; then
 
246
        # Install/update
 
247
        test "${TMPDIR+set}" = set || TMPDIR=/tmp
 
248
        tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
 
249
        (
 
250
            echo '<!DOCTYPE Menu PUBLIC "-//freedesktop//DTD Menu 1.0//EN"'
 
251
            echo '    "http://www.freedesktop.org/standards/menu-spec/menu-1.0.dtd">'
 
252
            echo '<!-- Do not edit manually - generated and managed by @NAME@ -->'
 
253
            echo '<Menu>'
 
254
            echo '    <Name>Applications</Name>'
 
255
 
 
256
            for desktop_file in $directory_files; do
 
257
                basefile=`basename "$desktop_file"`
 
258
                basefilename=`echo "$basefile"|cut -d '.' -f 1`
 
259
                echo "<Menu>"
 
260
                echo "    <Name>$basefilename</Name>"
 
261
                echo "    <Directory>$basefile</Directory>"
 
262
            done
 
263
 
 
264
            echo "    <Include>"
 
265
            for desktop_file in $new_desktop_files; do
 
266
                echo "        <Filename>$desktop_file</Filename>"
 
267
            done
 
268
            echo "    </Include>"
 
269
 
 
270
            for desktop_file in $directory_files; do
 
271
                echo "</Menu>"
 
272
            done
 
273
 
 
274
            echo '</Menu>'
 
275
        ) > $tmpfile
 
276
        chmod $my_chmod $tmpfile
 
277
 
 
278
        save_umask=`umask`
 
279
        umask $my_umask
 
280
 
 
281
        mkdir -p $xdg_dir
 
282
        eval 'cp $tmpfile $xdg_dir/$menu_file'$xdg_redirect_output
 
283
 
 
284
        umask $save_umask
 
285
        rm -f "$tmpfile"
 
286
    else
 
287
        # Uninstall
 
288
        rm -f $xdg_dir/$menu_file
 
289
    fi
 
290
 
 
291
    # Uninstall .directory files only if no longer referenced
 
292
    if [ $action = "uninstall" ] ; then
 
293
        test "${TMPDIR+set}" = set || TMPDIR=/tmp
 
294
        tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
 
295
        for menu_file in $xdg_dir/*; do
 
296
            if grep 'generated and managed by @NAME@' $menu_file > /dev/null 2> /dev/null; then
 
297
                awk '
 
298
# List all files within <Directory> tags
 
299
BEGIN {
 
300
  RS="<"
 
301
}
 
302
/^Directory/ {
 
303
  if (match($0,/>/)) {
 
304
     print substr($0,RSTART+1)
 
305
  }
 
306
}' $menu_file >> $tmpfile
 
307
            fi
 
308
        done
 
309
        orig_directory_files="$directory_files"
 
310
        directory_files=
 
311
        for desktop_file in $orig_directory_files; do
 
312
            if ! grep '^'$desktop_file'$' $tmpfile > /dev/null 2> /dev/null; then
 
313
                # No longer in use, safe to delete
 
314
               directory_files="$directory_files $desktop_file"
 
315
            fi
 
316
        done
 
317
        rm -f "$tmpfile"
 
318
    fi
 
319
}
 
320
 
 
321
 
 
322
[ x"$1" != x"" ] || exit_failure_syntax
 
323
 
 
324
mode=
 
325
action=
 
326
update=yes
 
327
desktop_files=
 
328
directory_files=
 
329
 
 
330
case $1 in
 
331
  install)
 
332
    action=install
 
333
    ;;
 
334
 
 
335
  uninstall)
 
336
    action=uninstall
 
337
    ;;
 
338
 
 
339
  forceupdate)
 
340
    action=forceupdate
 
341
    ;;
 
342
 
 
343
  *)
 
344
    exit_failure_syntax "unknown command '$1'"
 
345
    ;;
 
346
esac
 
347
 
 
348
shift
 
349
 
 
350
vendor=true
 
351
while [ $# -gt 0 ] ; do
 
352
    parm="$1"
 
353
    shift
 
354
 
 
355
    case "$parm" in
 
356
      --noupdate)
 
357
        update=no
 
358
        ;;
 
359
 
 
360
      --mode)
 
361
        if [ -z "$1" ] ; then
 
362
            exit_failure_syntax "mode argument missing for --mode"
 
363
        fi
 
364
        case "$1" in
 
365
          user)
 
366
            mode="user"
 
367
            ;;
 
368
 
 
369
          system)
 
370
            mode="system"
 
371
            ;;
 
372
 
 
373
          *)
 
374
            exit_failure_syntax "unknown mode '$1'"
 
375
            ;;
 
376
        esac
 
377
        shift
 
378
        ;;
 
379
 
 
380
      --novendor)
 
381
        vendor=false
 
382
        ;;
 
383
 
 
384
      -*)
 
385
        exit_failure_syntax "unexpected option '$parm'"
 
386
        ;;
 
387
 
 
388
      *)
 
389
        if [ "$action" = "install" ] ; then
 
390
            check_input_file "$parm"
 
391
        fi
 
392
        case "$parm" in
 
393
           *.directory)
 
394
              if [ -n "$desktop_files" ] ; then
 
395
                  exit_failure_syntax "'$parm' must preceed any *.desktop file"
 
396
              fi
 
397
              directory_files="$directory_files $parm"
 
398
              ;;
 
399
           *.desktop)
 
400
              desktop_files="$desktop_files $parm"
 
401
              ;;
 
402
           *)
 
403
              exit_failure_syntax "file to $action must be a *.directory or *.desktop file"
 
404
              ;;
 
405
        esac
 
406
        ;;
 
407
    esac
 
408
done
 
409
 
 
410
# Shouldn't happen
 
411
if [ -z "$action" ] ; then
 
412
    exit_failure_syntax "command argument missing"
 
413
fi
 
414
 
 
415
if [ -n "$XDG_UTILS_INSTALL_MODE" ] ; then
 
416
    if [ "$XDG_UTILS_INSTALL_MODE" = "system" ] ; then
 
417
        mode="system"
 
418
    elif [ "$XDG_UTILS_INSTALL_MODE" = "user" ] ; then
 
419
        mode="user"
 
420
    fi
 
421
fi
 
422
 
 
423
if [ -z "$mode" ] ; then
 
424
    if [ `whoami` = "root" ] ; then
 
425
       mode="system"
 
426
    else
 
427
       mode="user"
 
428
    fi
 
429
fi
 
430
 
 
431
if [ x"$action" = x"forceupdate" ] ; then
 
432
    update_desktop_database
 
433
    exit_success
 
434
fi
 
435
 
 
436
if [ -z "$desktop_files" ] ; then
 
437
    exit_failure_syntax "desktop-file argument missing"
 
438
fi
 
439
 
 
440
menu_name=
 
441
for desktop_file in $directory_files; do
 
442
    if [ "$vendor" =  "true" -a "$action" = "install" ] ; then
 
443
        check_vendor_prefix "$desktop_file"
 
444
    fi
 
445
 
 
446
    basefilename=`basename "$desktop_file" | cut -d '.' -f 1`
 
447
    if [ -z "$menu_name" ] ; then
 
448
        menu_name="$basefilename"
 
449
    else
 
450
        menu_name="$menu_name-$basefilename"
 
451
    fi
 
452
done
 
453
 
 
454
if [ -n "$menu_name" ] ; then
 
455
    if [ x"$mode" = x"user" ] ; then
 
456
        update_submenu "user-$menu_name.menu"
 
457
    else
 
458
        update_submenu "$menu_name.menu"
 
459
    fi
 
460
else
 
461
    # Work around for SUSE/gnome 2.12 to pick up new ~/.local/share/applications
 
462
    if [ x"$mode" = x"user" ] ; then
 
463
        update_submenu
 
464
    fi
 
465
fi
 
466
 
 
467
# Install *.directory files
 
468
 
 
469
xdg_dir_name=desktop-directories
 
470
 
 
471
xdg_user_dir="$XDG_DATA_HOME"
 
472
[ -n "$xdg_user_dir" ] || xdg_user_dir="$HOME/.local/share"
 
473
xdg_user_dir="$xdg_user_dir/$xdg_dir_name"
 
474
 
 
475
xdg_system_dirs="$XDG_DATA_DIRS"
 
476
[ -n "$xdg_system_dirs" ] || xdg_system_dirs=/usr/local/share/:/usr/share/
 
477
xdg_global_dir=
 
478
for x in `echo $xdg_system_dirs | sed 's/:/ /g'` ; do
 
479
    if [ -w $x/$xdg_dir_name ] ; then
 
480
        xdg_global_dir="$x/$xdg_dir_name"
 
481
        break
 
482
    fi
 
483
done
 
484
 
 
485
DEBUG 3 "Install locations for *.directory files:"
 
486
DEBUG 3 "xdg_user_dir: $xdg_user_dir"
 
487
DEBUG 3 "xdg_global_dir: $xdg_global_dir"
 
488
DEBUG 3 "kde_user_dir: $kde_user_dir"
 
489
DEBUG 3 "kde_global_dir: $kde_global_dir"
 
490
DEBUG 3 "gnome_user_dir: $gnome_user_dir"
 
491
DEBUG 3 "gnome_global_dir: $gnome_global_dir"
 
492
 
 
493
if [ x"$mode" = x"user" ] ; then
 
494
    xdg_dir="$xdg_user_dir"
 
495
    kde_dir="$kde_user_dir"
 
496
    gnome_dir="$gnome_user_dir"
 
497
    my_umask=077
 
498
else
 
499
    xdg_dir="$xdg_global_dir"
 
500
    kde_dir="$kde_global_dir"
 
501
    gnome_dir="$gnome_global_dir"
 
502
    my_umask=022
 
503
    if [ -z "${xdg_dir}${kde_dir}${gnome_dir}" ] ; then
 
504
        exit_failure_operation_impossible "No writable system menu directory found."
 
505
    fi
 
506
fi
 
507
 
 
508
for desktop_file in $directory_files; do
 
509
    basefile=`basename "$desktop_file"`
 
510
 
 
511
    DEBUG 1 "$action $desktop_file in $xdg_dir $kde_dir $gnome_dir"
 
512
 
 
513
    case $action in
 
514
        install)
 
515
            save_umask=`umask`
 
516
            umask $my_umask
 
517
 
 
518
            for x in $xdg_dir $kde_dir $gnome_dir ; do
 
519
                mkdir -p $x
 
520
                eval 'cp $desktop_file $x/$basefile'$xdg_redirect_output
 
521
            done
 
522
 
 
523
            umask $save_umask
 
524
            ;;
 
525
 
 
526
        uninstall)
 
527
            for x in $xdg_dir $kde_dir $gnome_dir ; do
 
528
                rm -f $x/$basefile
 
529
            done
 
530
 
 
531
            ;;
 
532
    esac
 
533
done
 
534
 
 
535
# Install *.desktop files
 
536
xdg_dir_name=applications
 
537
 
 
538
xdg_user_dir="$XDG_DATA_HOME"
 
539
[ -n "$xdg_user_dir" ] || xdg_user_dir="$HOME/.local/share"
 
540
xdg_user_dir="$xdg_user_dir/$xdg_dir_name"
 
541
 
 
542
xdg_system_dirs="$XDG_DATA_DIRS"
 
543
[ -n "$xdg_system_dirs" ] || xdg_system_dirs=/usr/local/share/:/usr/share/
 
544
xdg_global_dir=
 
545
for x in `echo $xdg_system_dirs | sed 's/:/ /g'` ; do
 
546
    if [ -w $x/$xdg_dir_name ] ; then
 
547
        xdg_global_dir="$x/$xdg_dir_name"
 
548
        break
 
549
    fi
 
550
done
 
551
 
 
552
kde_user_dir=`kde${KDE_SESSION_VERSION}-config --path apps 2> /dev/null | cut -d ':' -f 1`
 
553
kde_global_dir=`kde${KDE_SESSION_VERSION}-config --path apps 2> /dev/null | cut -d ':' -f 2`
 
554
[ -w $kde_global_dir ] || kde_global_dir=
 
555
 
 
556
gnome_user_dir="$HOME/.gnome/apps"
 
557
gnome_global_dir="/usr/share/gnome/apps"
 
558
[ -w $gnome_global_dir ] || gnome_global_dir=
 
559
 
 
560
DEBUG 3 "Install locations for *.desktop files:"
 
561
DEBUG 3 "xdg_user_dir: $xdg_user_dir"
 
562
DEBUG 3 "xdg_global_dir: $xdg_global_dir"
 
563
DEBUG 3 "kde_user_dir: $kde_user_dir"
 
564
DEBUG 3 "kde_global_dir: $kde_global_dir"
 
565
DEBUG 3 "gnome_user_dir: $gnome_user_dir"
 
566
DEBUG 3 "gnome_global_dir: $gnome_global_dir"
 
567
 
 
568
if [ x"$mode" = x"user" ] ; then
 
569
    xdg_dir="$xdg_user_dir"
 
570
    kde_dir="$kde_user_dir"
 
571
    gnome_dir="$gnome_user_dir"
 
572
    my_umask=077
 
573
else
 
574
    xdg_dir="$xdg_global_dir"
 
575
    kde_dir="$kde_global_dir"
 
576
    gnome_dir="$gnome_global_dir"
 
577
    my_umask=022
 
578
    if [ -z "${xdg_dir}${kde_dir}${gnome_dir}" ] ; then
 
579
        exit_failure_operation_impossible "No writable system menu directory found."
 
580
    fi
 
581
fi
 
582
 
 
583
for desktop_file in $desktop_files; do
 
584
    if [ "$vendor" =  "true" -a "$action" = "install" ] ; then
 
585
        check_vendor_prefix "$desktop_file"
 
586
    fi
 
587
 
 
588
    basefile=`basename "$desktop_file"`
 
589
 
 
590
    DEBUG 1 "$action $desktop_file in $xdg_dir $kde_dir $gnome_dir"
 
591
 
 
592
    case $action in
 
593
        install)
 
594
            save_umask=`umask`
 
595
            umask $my_umask
 
596
 
 
597
            for x in $xdg_dir $kde_dir $gnome_dir ; do
 
598
                mkdir -p $x
 
599
                eval 'cp $desktop_file $x/$basefile'$xdg_redirect_output
 
600
            done
 
601
 
 
602
            if [ -f $kde_dir/$basefile ] ; then
 
603
                echo "OnlyShowIn=Old;" >> $kde_dir/$basefile
 
604
            fi
 
605
 
 
606
            if [ -f $gnome_dir/$basefile ] ; then
 
607
                echo "OnlyShowIn=Old;" >> $gnome_dir/$basefile
 
608
            fi
 
609
 
 
610
            make_lazy_default "$xdg_dir" "$basefile"
 
611
 
 
612
            umask $save_umask
 
613
            ;;
 
614
 
 
615
        uninstall)
 
616
            for x in $xdg_dir $kde_dir $gnome_dir ; do
 
617
                rm -f $x/$basefile
 
618
            done
 
619
 
 
620
            ;;
 
621
    esac
 
622
done
 
623
 
 
624
if [ x"$update" = x"yes" ] ; then
 
625
    update_desktop_database
 
626
fi
 
627
 
 
628
exit_success