~willismonroe/ubuntu/precise/xdg-utils/typo-fix-996304

« back to all changes in this revision

Viewing changes to .pc/debian-changes-1.1.0~rc1-2ubuntu4/scripts/xdg-mime

  • Committer: Bazaar Package Importer
  • Author(s): Jamie Strandboge
  • Date: 2011-07-13 08:50:04 UTC
  • Revision ID: james.westby@ubuntu.com-20110713085004-jq4p6e1mnewhadw5
Tags: 1.1.0~rc1-2ubuntu5
rename debian/patches/debian-changes-1.1.0~rc1-2ubuntu4 to
lp779156-lubuntu.diff and make DEP-3 compliant. Correctly reference
LP: #779156 so the bug gets auto-closed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/bin/sh
2
 
#---------------------------------------------
3
 
#   xdg-mime
4
 
#
5
 
#   Utility script to manipulate MIME related information
6
 
#   on XDG compliant systems.
7
 
#
8
 
#   Refer to the usage() function below for usage.
9
 
#
10
 
#   Copyright 2009-2010, Fathi Boudra <fabo@freedesktop.org>
11
 
#   Copyright 2009-2010, Rex Dieter <rdieter@fedoraproject.org>
12
 
#   Copyright 2006, Kevin Krammer <kevin.krammer@gmx.at>
13
 
#   Copyright 2006, Jeremy White <jwhite@codeweavers.com>
14
 
#
15
 
#   LICENSE:
16
 
#
17
 
#   Permission is hereby granted, free of charge, to any person obtaining a
18
 
#   copy of this software and associated documentation files (the "Software"),
19
 
#   to deal in the Software without restriction, including without limitation
20
 
#   the rights to use, copy, modify, merge, publish, distribute, sublicense,
21
 
#   and/or sell copies of the Software, and to permit persons to whom the
22
 
#   Software is furnished to do so, subject to the following conditions:
23
 
#
24
 
#   The above copyright notice and this permission notice shall be included
25
 
#   in all copies or substantial portions of the Software.
26
 
#
27
 
#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
28
 
#   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29
 
#   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
30
 
#   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
31
 
#   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
32
 
#   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
33
 
#   OTHER DEALINGS IN THE SOFTWARE.
34
 
#
35
 
#---------------------------------------------
36
 
 
37
 
manualpage()
38
 
{
39
 
cat << _MANUALPAGE
40
 
Name
41
 
 
42
 
xdg-mime - command line tool for querying information about file type handling
43
 
and adding descriptions for new file types
44
 
 
45
 
Synopsis
46
 
 
47
 
xdg-mime query { filetype | default } ...
48
 
 
49
 
xdg-mime default application mimetype(s)
50
 
 
51
 
xdg-mime install [--mode mode] [--novendor] mimetypes-file
52
 
 
53
 
xdg-mime uninstall [--mode mode] mimetypes-file
54
 
 
55
 
xdg-mime { --help | --manual | --version }
56
 
 
57
 
Description
58
 
 
59
 
The xdg-mime program can be used to query information about file types and to
60
 
add descriptions for new file types.
61
 
 
62
 
Commands
63
 
 
64
 
query
65
 
 
66
 
    Returns information related to file types.
67
 
 
68
 
    The query option is for use inside a desktop session only. It is not
69
 
    recommended to use xdg-mime query as root.
70
 
 
71
 
    The following queries are supported:
72
 
 
73
 
    query filetype FILE: Returns the file type of FILE in the form of a MIME
74
 
    type.
75
 
 
76
 
    query default mimetype: Returns the default application that the desktop
77
 
    environment uses for opening files of type mimetype. The default
78
 
    application is identified by its *.desktop file.
79
 
 
80
 
default
81
 
 
82
 
    Ask the desktop environment to make application the default application for
83
 
    opening files of type mimetype. An application can be made the default for
84
 
    several file types by specifying multiple mimetypes.
85
 
 
86
 
    application is the desktop file id of the application and has the form
87
 
    vendor-name.desktop application must already be installed in the desktop
88
 
    menu before it can be made the default handler. The aplication's desktop
89
 
    file must list support for all the MIME types that it wishes to be the
90
 
    default handler for.
91
 
 
92
 
    Requests to make an application a default handler may be subject to system
93
 
    policy or approval by the end-user. xdg-mime query can be used to verify
94
 
    whether an application is the actual default handler for a specific file
95
 
    type.
96
 
 
97
 
    The default option is for use inside a desktop session only. It is not
98
 
    recommended to use xdg-mime default as root.
99
 
 
100
 
install
101
 
    Adds the file type descriptions provided in mimetypes-file to the desktop
102
 
    environment. mimetypes-file must be a XML file that follows the
103
 
    freedesktop.org Shared MIME-info Database specification and that has a
104
 
    mime-info element as its document root. For each new file type one or more
105
 
    icons with name type-subtype must be installed with the xdg-icon-resource
106
 
    command in the mimetypes context. For example the filetype application/
107
 
    vnd.oasis.opendocument.text requires an icon named
108
 
    application-vnd.oasis.opendocument.text to be installed (unless the file
109
 
    type recommends another icon name).
110
 
uninstall
111
 
    Removes the file type descriptions provided in mimetypes-file and
112
 
    previously added with xdg-mime install from the desktop environment.
113
 
    mimetypes-file must be a XML file that follows the freedesktop.org Shared
114
 
    MIME-info Database specification and that has a mime-info element as its
115
 
    document root.
116
 
 
117
 
Options
118
 
 
119
 
--mode mode
120
 
 
121
 
    mode can be user or system. In user mode the file is (un)installed for the
122
 
    current user only. In system mode the file is (un)installed for all users
123
 
    on the system. Usually only root is allowed to install in system mode.
124
 
 
125
 
    The default is to use system mode when called by root and to use user mode
126
 
    when called by a non-root user.
127
 
 
128
 
--novendor
129
 
 
130
 
    Normally, xdg-mime checks to ensure that the mimetypes-file to be installed
131
 
    has a proper vendor prefix. This option can be used to disable that check.
132
 
 
133
 
    A vendor prefix consists of alpha characters ([a-zA-Z]) and is terminated
134
 
    with a dash ("-"). Companies and organizations are encouraged to use a word
135
 
    or phrase, preferably the organizations name, for which they hold a
136
 
    trademark as their vendor prefix. The purpose of the vendor prefix is to
137
 
    prevent name conflicts.
138
 
 
139
 
--help
140
 
    Show command synopsis.
141
 
--manual
142
 
    Show this manualpage.
143
 
--version
144
 
    Show the xdg-utils version information.
145
 
 
146
 
Environment Variables
147
 
 
148
 
xdg-mime honours the following environment variables:
149
 
 
150
 
XDG_UTILS_DEBUG_LEVEL
151
 
    Setting this environment variable to a non-zero numerical value makes
152
 
    xdg-mime do more verbose reporting on stderr. Setting a higher value
153
 
    increases the verbosity.
154
 
XDG_UTILS_INSTALL_MODE
155
 
    This environment variable can be used by the user or administrator to
156
 
    override the installation mode. Valid values are user and system.
157
 
 
158
 
Exit Codes
159
 
 
160
 
An exit code of 0 indicates success while a non-zero exit code indicates
161
 
failure. The following failure codes can be returned:
162
 
 
163
 
1
164
 
    Error in command line syntax.
165
 
2
166
 
    One of the files passed on the command line did not exist.
167
 
3
168
 
    A required tool could not be found.
169
 
4
170
 
    The action failed.
171
 
5
172
 
    No permission to read one of the files passed on the command line.
173
 
 
174
 
See Also
175
 
 
176
 
xdg-icon-resource(1), xdg-desktop-menu(1)
177
 
 
178
 
Examples
179
 
 
180
 
xdg-mime query filetype /tmp/foobar.png
181
 
 
182
 
Prints the MIME type of the file /tmp/foobar.png, in this case image/png
183
 
 
184
 
xdg-mime query default image/png
185
 
 
186
 
Prints the .desktop filename of the application which is registered to open PNG
187
 
files.
188
 
 
189
 
xdg-mime install shinythings-shiny.xml
190
 
 
191
 
Adds a file type description for "shiny"-files. "shinythings-" is used as the
192
 
vendor prefix. The file type description could look as folows.
193
 
 
194
 
shinythings-shiny.xml:
195
 
 
196
 
<?xml version="1.0"?>
197
 
<mime-info xmlns='http://www.freedesktop.org/standards/shared-mime-info'>
198
 
  <mime-type type="text/x-shiny">
199
 
    <comment>Shiny new file type</comment>
200
 
    <glob pattern="*.shiny"/>
201
 
    <glob pattern="*.shi"/>
202
 
  </mime-type>
203
 
</mime-info>
204
 
 
205
 
An icon for this new file type must also be installed, for example with:
206
 
 
207
 
xdg-icon-resource install --context mimetypes --size 64 shiny-file-icon.png text-x-shiny
208
 
 
209
 
_MANUALPAGE
210
 
}
211
 
 
212
 
usage()
213
 
{
214
 
cat << _USAGE
215
 
xdg-mime - command line tool for querying information about file type handling
216
 
and adding descriptions for new file types
217
 
 
218
 
Synopsis
219
 
 
220
 
xdg-mime query { filetype | default } ...
221
 
 
222
 
xdg-mime default application mimetype(s)
223
 
 
224
 
xdg-mime install [--mode mode] [--novendor] mimetypes-file
225
 
 
226
 
xdg-mime uninstall [--mode mode] mimetypes-file
227
 
 
228
 
xdg-mime { --help | --manual | --version }
229
 
 
230
 
_USAGE
231
 
}
232
 
 
233
 
#@xdg-utils-common@
234
 
 
235
 
#----------------------------------------------------------------------------
236
 
#   Common utility functions included in all XDG wrapper scripts
237
 
#----------------------------------------------------------------------------
238
 
 
239
 
DEBUG()
240
 
{
241
 
  [ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && return 0;
242
 
  [ ${XDG_UTILS_DEBUG_LEVEL} -lt $1 ] && return 0;
243
 
  shift
244
 
  echo "$@" >&2
245
 
}
246
 
 
247
 
#-------------------------------------------------------------
248
 
# Exit script on successfully completing the desired operation
249
 
 
250
 
exit_success()
251
 
{
252
 
    if [ $# -gt 0 ]; then
253
 
        echo "$@"
254
 
        echo
255
 
    fi
256
 
 
257
 
    exit 0
258
 
}
259
 
 
260
 
 
261
 
#-----------------------------------------
262
 
# Exit script on malformed arguments, not enough arguments
263
 
# or missing required option.
264
 
# prints usage information
265
 
 
266
 
exit_failure_syntax()
267
 
{
268
 
    if [ $# -gt 0 ]; then
269
 
        echo "xdg-mime: $@" >&2
270
 
        echo "Try 'xdg-mime --help' for more information." >&2
271
 
    else
272
 
        usage
273
 
        echo "Use 'man xdg-mime' or 'xdg-mime --manual' for additional info."
274
 
    fi
275
 
 
276
 
    exit 1
277
 
}
278
 
 
279
 
#-------------------------------------------------------------
280
 
# Exit script on missing file specified on command line
281
 
 
282
 
exit_failure_file_missing()
283
 
{
284
 
    if [ $# -gt 0 ]; then
285
 
        echo "xdg-mime: $@" >&2
286
 
    fi
287
 
 
288
 
    exit 2
289
 
}
290
 
 
291
 
#-------------------------------------------------------------
292
 
# Exit script on failure to locate necessary tool applications
293
 
 
294
 
exit_failure_operation_impossible()
295
 
{
296
 
    if [ $# -gt 0 ]; then
297
 
        echo "xdg-mime: $@" >&2
298
 
    fi
299
 
 
300
 
    exit 3
301
 
}
302
 
 
303
 
#-------------------------------------------------------------
304
 
# Exit script on failure returned by a tool application
305
 
 
306
 
exit_failure_operation_failed()
307
 
{
308
 
    if [ $# -gt 0 ]; then
309
 
        echo "xdg-mime: $@" >&2
310
 
    fi
311
 
 
312
 
    exit 4
313
 
}
314
 
 
315
 
#------------------------------------------------------------
316
 
# Exit script on insufficient permission to read a specified file
317
 
 
318
 
exit_failure_file_permission_read()
319
 
{
320
 
    if [ $# -gt 0 ]; then
321
 
        echo "xdg-mime: $@" >&2
322
 
    fi
323
 
 
324
 
    exit 5
325
 
}
326
 
 
327
 
#------------------------------------------------------------
328
 
# Exit script on insufficient permission to write a specified file
329
 
 
330
 
exit_failure_file_permission_write()
331
 
{
332
 
    if [ $# -gt 0 ]; then
333
 
        echo "xdg-mime: $@" >&2
334
 
    fi
335
 
 
336
 
    exit 6
337
 
}
338
 
 
339
 
check_input_file()
340
 
{
341
 
    if [ ! -e "$1" ]; then
342
 
        exit_failure_file_missing "file '$1' does not exist"
343
 
    fi
344
 
    if [ ! -r "$1" ]; then
345
 
        exit_failure_file_permission_read "no permission to read file '$1'"
346
 
    fi
347
 
}
348
 
 
349
 
check_vendor_prefix()
350
 
{
351
 
    file_label="$2"
352
 
    [ -n "$file_label" ] || file_label="filename"
353
 
    file=`basename "$1"`
354
 
    case "$file" in
355
 
       [a-zA-Z]*-*)
356
 
         return
357
 
         ;;
358
 
    esac
359
 
 
360
 
    echo "xdg-mime: $file_label '$file' does not have a proper vendor prefix" >&2
361
 
    echo 'A vendor prefix consists of alpha characters ([a-zA-Z]) and is terminated' >&2
362
 
    echo 'with a dash ("-"). An example '"$file_label"' is '"'example-$file'" >&2
363
 
    echo "Use --novendor to override or 'xdg-mime --manual' for additional info." >&2
364
 
    exit 1
365
 
}
366
 
 
367
 
check_output_file()
368
 
{
369
 
    # if the file exists, check if it is writeable
370
 
    # if it does not exists, check if we are allowed to write on the directory
371
 
    if [ -e "$1" ]; then
372
 
        if [ ! -w "$1" ]; then
373
 
            exit_failure_file_permission_write "no permission to write to file '$1'"
374
 
        fi
375
 
    else
376
 
        DIR=`dirname "$1"`
377
 
        if [ ! -w "$DIR" -o ! -x "$DIR" ]; then
378
 
            exit_failure_file_permission_write "no permission to create file '$1'"
379
 
        fi
380
 
    fi
381
 
}
382
 
 
383
 
#----------------------------------------
384
 
# Checks for shared commands, e.g. --help
385
 
 
386
 
check_common_commands()
387
 
{
388
 
    while [ $# -gt 0 ] ; do
389
 
        parm="$1"
390
 
        shift
391
 
 
392
 
        case "$parm" in
393
 
            --help)
394
 
            usage
395
 
            echo "Use 'man xdg-mime' or 'xdg-mime --manual' for additional info."
396
 
            exit_success
397
 
            ;;
398
 
 
399
 
            --manual)
400
 
            manualpage
401
 
            exit_success
402
 
            ;;
403
 
 
404
 
            --version)
405
 
            echo "xdg-mime 1.0.2"
406
 
            exit_success
407
 
            ;;
408
 
        esac
409
 
    done
410
 
}
411
 
 
412
 
check_common_commands "$@"
413
 
 
414
 
[ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && unset XDG_UTILS_DEBUG_LEVEL;
415
 
if [ ${XDG_UTILS_DEBUG_LEVEL-0} -lt 1 ]; then
416
 
    # Be silent
417
 
    xdg_redirect_output=" > /dev/null 2> /dev/null"
418
 
else
419
 
    # All output to stderr
420
 
    xdg_redirect_output=" >&2"
421
 
fi
422
 
 
423
 
#--------------------------------------
424
 
# Checks for known desktop environments
425
 
# set variable DE to the desktop environments name, lowercase
426
 
 
427
 
detectDE()
428
 
{
429
 
    if [ x"$KDE_FULL_SESSION" = x"true" ]; then DE=kde;
430
 
    elif [ x"$GNOME_DESKTOP_SESSION_ID" != x"" ]; then DE=gnome;
431
 
    elif `dbus-send --print-reply --dest=org.freedesktop.DBus /org/freedesktop/DBus org.freedesktop.DBus.GetNameOwner string:org.gnome.SessionManager > /dev/null 2>&1` ; then DE=gnome;
432
 
    elif xprop -root _DT_SAVE_MODE 2> /dev/null | grep ' = \"xfce4\"$' >/dev/null 2>&1; then DE=xfce;
433
 
    elif [ x"$DESKTOP_SESSION" = x"LXDE" ]; then DE=lxde;
434
 
    else DE=""
435
 
    fi
436
 
}
437
 
 
438
 
#----------------------------------------------------------------------------
439
 
# kfmclient exec/openURL can give bogus exit value in KDE <= 3.5.4
440
 
# It also always returns 1 in KDE 3.4 and earlier
441
 
# Simply return 0 in such case
442
 
 
443
 
kfmclient_fix_exit_code()
444
 
{
445
 
    version=`kde${KDE_SESSION_VERSION}-config --version 2>/dev/null | grep '^KDE'`
446
 
    major=`echo $version | sed 's/KDE.*: \([0-9]\).*/\1/'`
447
 
    minor=`echo $version | sed 's/KDE.*: [0-9]*\.\([0-9]\).*/\1/'`
448
 
    release=`echo $version | sed 's/KDE.*: [0-9]*\.[0-9]*\.\([0-9]\).*/\1/'`
449
 
    test "$major" -gt 3 && return $1
450
 
    test "$minor" -gt 5 && return $1
451
 
    test "$release" -gt 4 && return $1
452
 
    return 0
453
 
}
454
 
 
455
 
update_mime_database()
456
 
{
457
 
   if [ x"$mode" = x"user" -a -n "$DISPLAY" ] ; then
458
 
      detectDE
459
 
      if [ x"$DE" = x"kde" ] ; then
460
 
         DEBUG 1 "Running kbuildsycoca"
461
 
         if [ x"$KDE_SESSION_VERSION" = x"4" ]; then
462
 
             eval 'kbuildsycoca4'$xdg_redirect_output
463
 
         else
464
 
             eval 'kbuildsycoca'$xdg_redirect_output
465
 
         fi
466
 
      fi
467
 
   fi
468
 
   for x in `echo "$PATH:/opt/gnome/bin" | sed 's/:/ /g'`; do
469
 
      if [ -x $x/update-mime-database ] ; then
470
 
         DEBUG 1 "Running $x/update-mime-database $1"
471
 
         eval '$x/update-mime-database $1'$xdg_redirect_output
472
 
         return
473
 
      fi
474
 
   done
475
 
}
476
 
 
477
 
info_kde()
478
 
{
479
 
    if [ x"$KDE_SESSION_VERSION" = x"4" ]; then
480
 
        DEBUG 1 "Running kmimetypefinder \"$1\""
481
 
        KMIMETYPEFINDER=`which kmimetypefinder 2>/dev/null`
482
 
        $KMIMETYPEFINDER "$1" 2>/dev/null | head -n 1
483
 
    else
484
 
        DEBUG 1 "Running kfile \"$1\""
485
 
        KFILE=`which kfile 2>/dev/null`
486
 
        $KFILE "$1" 2> /dev/null | head -n 1 | cut -d "(" -f 2 | cut -d ")" -f 1
487
 
    fi
488
 
 
489
 
    if [ $? -eq 0 ]; then
490
 
        exit_success
491
 
    else
492
 
        exit_failure_operation_failed
493
 
    fi
494
 
}
495
 
 
496
 
info_gnome()
497
 
{
498
 
    if gvfs-info --help 2>/dev/null 1>&2; then
499
 
        DEBUG 1 "Running gvfs-info \"$1\""
500
 
        gvfs-info "$1" 2> /dev/null | grep standard::content-type | cut -d' ' -f4
501
 
    elif gnomevfs-info --help 2>/dev/null 1>&2; then
502
 
        DEBUG 1 "Running gnomevfs-info \"$1\""
503
 
        gnomevfs-info --slow-mime "$1" 2> /dev/null | grep "^MIME" | cut -d ":" -f 2 | sed s/"^ "//
504
 
    elif mimetype --version >/dev/null 2>&1; then
505
 
        DEBUG 1 "Running mimetype -b \"$1\""
506
 
        mimetype -b "$1"
507
 
    else
508
 
        DEBUG 1 "Running file -i \"$1\""
509
 
        /usr/bin/file -i "$1" 2> /dev/null | cut -d ":" -f 2 | sed s/"^ "//
510
 
    fi
511
 
 
512
 
    if [ $? -eq 0 ]; then
513
 
        exit_success
514
 
    else
515
 
        exit_failure_operation_failed
516
 
    fi
517
 
}
518
 
 
519
 
info_generic()
520
 
{
521
 
    if mimetype --version >/dev/null 2>&1; then
522
 
        DEBUG 1 "Running mimetype -b \"$1\""
523
 
        mimetype -b "$1"
524
 
    else
525
 
        DEBUG 1 "Running file -i \"$1\""
526
 
        /usr/bin/file -i "$1" 2> /dev/null | cut -d ":" -f 2 | sed s/"^ "//
527
 
    fi
528
 
 
529
 
    if [ $? -eq 0 ]; then
530
 
        exit_success
531
 
    else
532
 
        exit_failure_operation_failed
533
 
    fi
534
 
}
535
 
 
536
 
make_default_kde()
537
 
{
538
 
    # $1 is vendor-name.desktop
539
 
    # $2 is mime/type
540
 
    #
541
 
    # On KDE 3, add to $KDE_CONFIG_PATH/profilerc:
542
 
    # [$2 - 1]
543
 
    # Application=$1
544
 
    #
545
 
    # Remove all [$2 - *] sections, or even better,
546
 
    # renumber [$2 - *] sections and remove duplicate
547
 
    #
548
 
    # On KDE 4, add $2=$1 to $XDG_DATA_APPS/mimeapps.list
549
 
    #
550
 
    # Example file:
551
 
    #
552
 
    # [Added Associations]
553
 
    # text/plain=kde4-kate.desktop;kde4-kwrite.desktop;
554
 
    #
555
 
    # [Removed Associations]
556
 
    # text/plain=gnome-gedit.desktop;gnu-emacs.desktop;
557
 
    vendor="$1"
558
 
    mimetype="$2"
559
 
    if [ x"$KDE_SESSION_VERSION" = x"4" ]; then
560
 
        default_dir=`kde4-config --path xdgdata-apps 2> /dev/null | cut -d ':' -f 1`
561
 
        default_file="$default_dir/mimeapps.list"
562
 
    else
563
 
        default_dir=`kde-config --path config 2> /dev/null | cut -d ':' -f 1`
564
 
        default_file="$default_dir/profilerc"
565
 
    fi
566
 
    if [ -z "$default_dir" ]; then
567
 
        DEBUG 2 "make_default_kde: No kde runtime detected"
568
 
        return
569
 
    fi
570
 
    DEBUG 2 "make_default_kde $vendor $mimetype"
571
 
    DEBUG 1 "Updating $default_file"
572
 
    mkdir -p "$default_dir"
573
 
    [ -f $default_file ] || touch $default_file
574
 
    if [ x"$KDE_SESSION_VERSION" = x"4" ]; then
575
 
        [ -f $default_file ] || touch $default_file
576
 
        awk -v application="$vendor" -v mimetype="$mimetype" '
577
 
    BEGIN {
578
 
        prefix=mimetype "="
579
 
        associations=0
580
 
        found=0
581
 
        blanks=0
582
 
    }
583
 
    {
584
 
        suppress=0
585
 
        if (index($0, "[Added Associations]") == 1) {
586
 
            associations=1
587
 
        } else if (index($0, "[") == 1) {
588
 
            if (associations && !found) {
589
 
                print prefix application
590
 
                found=1
591
 
            }
592
 
            associations=0
593
 
        } else if ($0 == "") {
594
 
            blanks++
595
 
            suppress=1
596
 
        } else if (associations && index($0, prefix) == 1) {
597
 
            value=substr($0, length(prefix) + 1, length)
598
 
            split(value, apps, ";")
599
 
            value=application ";"
600
 
            count=0
601
 
            for (i in apps) {
602
 
              count++
603
 
            }
604
 
            for (i=0; i < count; i++) {
605
 
                if (apps[i] != application && apps[i] != "") {
606
 
                    value=value apps[i] ";"
607
 
                }
608
 
            }
609
 
            $0=prefix value
610
 
            found=1
611
 
        }
612
 
        if (!suppress) {
613
 
            while (blanks > 0) {
614
 
                print ""
615
 
                blanks--
616
 
            }
617
 
            print $0
618
 
        }
619
 
    }
620
 
    END {
621
 
        if (!found) {
622
 
            if (!associations) {
623
 
                print "[Added Associations]"
624
 
            }
625
 
            print prefix application
626
 
        }
627
 
        while (blanks > 0) {
628
 
            print ""
629
 
            blanks--
630
 
        }
631
 
    }
632
 
' $default_file > ${default_file}.new && mv ${default_file}.new $default_file
633
 
        eval 'kbuildsycoca4'$xdg_redirect_output
634
 
    else
635
 
        awk -v application="$vendor" -v mimetype="$mimetype" '
636
 
    BEGIN {
637
 
        header_start="[" mimetype " - "
638
 
        suppress=0
639
 
    }
640
 
    {
641
 
        if (index($0, header_start) == 1 )
642
 
            suppress=1
643
 
        else
644
 
            if (/^\[/) { suppress=0 }
645
 
 
646
 
        if (!suppress) {
647
 
            print $0
648
 
        }
649
 
    }
650
 
    END {
651
 
        print ""
652
 
        print "[" mimetype " - 1]"
653
 
        print "Application=" application
654
 
        print "AllowAsDefault=true"
655
 
        print "GenericServiceType=Application"
656
 
        print "Preference=1"
657
 
        print "ServiceType=" mimetype
658
 
    }
659
 
' $default_file > ${default_file}.new && mv ${default_file}.new $default_file
660
 
    fi
661
 
}
662
 
 
663
 
make_default_generic()
664
 
{
665
 
    # $1 is vendor-name.desktop
666
 
    # $2 is mime/type
667
 
    # Add $2=$1 to XDG_DATA_HOME/applications/defaults.list
668
 
    xdg_user_dir="$XDG_DATA_HOME"
669
 
    [ -n "$xdg_user_dir" ] || xdg_user_dir="$HOME/.local/share"
670
 
    default_file="$xdg_user_dir/applications/mimeapps.list"
671
 
    DEBUG 2 "make_default_generic $1 $2"
672
 
    DEBUG 1 "Updating $default_file"
673
 
    awk -v mimetype="$2" -v application="$1" '
674
 
    BEGIN {
675
 
        prefix=mimetype "="
676
 
        indefault=0
677
 
        added=0
678
 
        blanks=0
679
 
        found=0
680
 
    }
681
 
    {
682
 
        suppress=0
683
 
        if (index($0, "[Default Applications]") == 1) {
684
 
            indefault=1
685
 
            found=1
686
 
        } else if (index($0, "[") == 1) {
687
 
            if (!added && indefault) {
688
 
                print prefix application
689
 
                added=1
690
 
            }
691
 
            indefault=0
692
 
        } else if ($0 == "") {
693
 
            suppress=1
694
 
            blanks++
695
 
        } else if (indefault && !added && index($0, prefix) == 1) {
696
 
                $0=prefix application
697
 
                added=1
698
 
        }
699
 
        if (!suppress) {
700
 
            while (blanks > 0) {
701
 
                print ""
702
 
                blanks--
703
 
            }
704
 
            print $0
705
 
        }
706
 
    }
707
 
    END {
708
 
        if (!added) {
709
 
            if (!found) {
710
 
                print ""
711
 
                print "[Default Applications]"
712
 
            }
713
 
            print prefix application
714
 
        }
715
 
        while (blanks > 0) {
716
 
            print ""
717
 
            blanks--
718
 
        }
719
 
    }
720
 
'   $default_file > ${default_file}.new && mv ${default_file}.new $default_file
721
 
}
722
 
 
723
 
defapp_generic()
724
 
{
725
 
    MIME="$1"
726
 
    xdg_user_dir="$XDG_DATA_HOME"
727
 
    [ -n "$xdg_user_dir" ] || xdg_user_dir="$HOME/.local/share"
728
 
    xdg_user_dir="$xdg_user_dir/$xdg_dir_name"
729
 
    xdg_system_dirs="$XDG_DATA_DIRS"
730
 
    [ -n "$xdg_system_dirs" ] || xdg_system_dirs=/usr/local/share/:/usr/share/
731
 
 
732
 
    for x in `echo "$xdg_user_dir" | sed 's/:/ /g'`; do
733
 
        mimeapps_list="$x/applications/mimeapps.list"
734
 
        if [ -f "$mimeapps_list" ] ; then
735
 
            trader_result=`awk -v mimetype="$MIME" '
736
 
    BEGIN {
737
 
        prefix=mimetype "="
738
 
        indefault=0
739
 
        found=0
740
 
    }
741
 
    {
742
 
        if (index($0, "[Default Applications]") == 1) {
743
 
            indefault=1
744
 
        } else if (index($0, "[") == 1) {
745
 
            indefault=0
746
 
        } else if (!found && indefault && index($0, prefix) == 1) {
747
 
            print substr($0, length(prefix) +1, length)
748
 
            found=1
749
 
        }
750
 
    }
751
 
'           $mimeapps_list`
752
 
            if [ -n "$trader_result" ] ; then
753
 
                echo $trader_result
754
 
                exit_success
755
 
            fi
756
 
        fi
757
 
    done
758
 
 
759
 
    for x in `echo "$xdg_system_dirs" | sed 's/:/ /g'`; do
760
 
       DEBUG 2 "Checking $x/applications/defaults.list"
761
 
       trader_result=`grep "$MIME=" $x/applications/defaults.list 2> /dev/null | cut -d '=' -f 2 | cut -d ';' -f 1`
762
 
       if [ -n "$trader_result" ] ; then
763
 
          echo $trader_result
764
 
          exit_success
765
 
       fi
766
 
    done
767
 
    exit_success
768
 
}
769
 
 
770
 
defapp_kde()
771
 
{
772
 
    MIME="$1"
773
 
    if [ x"$KDE_SESSION_VERSION" = x"4" ]; then
774
 
        KTRADER=`which ktraderclient 2> /dev/null`
775
 
        MIMETYPE="--mimetype"
776
 
        SERVICETYPE="--servicetype"
777
 
    else
778
 
        KTRADER=`which ktradertest 2> /dev/null`
779
 
    fi
780
 
    if [ -n "$KTRADER" ] ; then
781
 
        DEBUG 1 "Running KDE trader query \"$MIME\" mimetype and \"Application\" servicetype"
782
 
        trader_result=`$KTRADER $MIMETYPE "$MIME" $SERVICETYPE Application 2>/dev/null \
783
 
            | grep DesktopEntryPath | head -n 1 | cut -d ':' -f 2 | cut -d \' -f 2`
784
 
        if [ -n "$trader_result" ] ; then
785
 
            basename "$trader_result"
786
 
            exit_success
787
 
        else
788
 
            exit_failure_operation_failed
789
 
        fi
790
 
    else
791
 
        defapp_generic "$1"
792
 
    fi
793
 
}
794
 
 
795
 
[ x"$1" != x"" ] || exit_failure_syntax
796
 
 
797
 
mode=
798
 
action=
799
 
filename=
800
 
mimetype=
801
 
 
802
 
case $1 in
803
 
  install)
804
 
    action=install
805
 
    ;;
806
 
 
807
 
  uninstall)
808
 
    action=uninstall
809
 
    ;;
810
 
 
811
 
  query)
812
 
    shift
813
 
 
814
 
    if [ -z "$1" ] ; then
815
 
        exit_failure_syntax "query type argument missing"
816
 
    fi
817
 
 
818
 
    case $1 in
819
 
      filetype)
820
 
        action=info
821
 
 
822
 
        filename="$2"
823
 
        if [ -z "$filename" ] ; then
824
 
            exit_failure_syntax "FILE argument missing"
825
 
        fi
826
 
        case $filename in
827
 
          -*)
828
 
            exit_failure_syntax "unexpected option '$filename'"
829
 
            ;;
830
 
        esac
831
 
        check_input_file "$filename"
832
 
        filename=$(readlink -f -- "$filename")
833
 
        ;;
834
 
 
835
 
      default)
836
 
        action=defapp
837
 
        mimetype="$2"
838
 
        if [ -z "$mimetype" ] ; then
839
 
            exit_failure_syntax "mimetype argument missing"
840
 
        fi
841
 
        case $mimetype in
842
 
          -*)
843
 
            exit_failure_syntax "unexpected option '$mimetype'"
844
 
            ;;
845
 
 
846
 
          */*)
847
 
            # Ok
848
 
            ;;
849
 
 
850
 
          *)
851
 
            exit_failure_syntax "mimetype '$mimetype' is not in the form 'minor/major'"
852
 
            ;;
853
 
        esac
854
 
        ;;
855
 
 
856
 
      *)
857
 
      exit_failure_syntax "unknown query type '$1'"
858
 
      ;;
859
 
    esac
860
 
    ;;
861
 
 
862
 
  default)
863
 
    action=makedefault
864
 
    shift
865
 
 
866
 
    if [ -z "$1" ] ; then
867
 
        exit_failure_syntax "application argument missing"
868
 
    fi
869
 
    case $1 in
870
 
      -*)
871
 
        exit_failure_syntax "unexpected option '$1'"
872
 
        ;;
873
 
 
874
 
      *.desktop)
875
 
        filename="$1"
876
 
        ;;
877
 
 
878
 
      *)
879
 
        exit_failure_syntax "malformed argument '$1', expected *.desktop"
880
 
        ;;
881
 
    esac
882
 
    ;;
883
 
 
884
 
  *)
885
 
  exit_failure_syntax "unknown command '$1'"
886
 
  ;;
887
 
esac
888
 
 
889
 
shift
890
 
 
891
 
 
892
 
if [ "$action" = "makedefault" ]; then
893
 
    if [ -z "$1" ] ; then
894
 
        exit_failure_syntax "mimetype argument missing"
895
 
    fi
896
 
 
897
 
    while [ $# -gt 0 ] ; do
898
 
        case $1 in
899
 
          -*)
900
 
            exit_failure_syntax "unexpected option '$1'"
901
 
            ;;
902
 
        esac
903
 
        mimetype="$1"
904
 
        shift
905
 
 
906
 
        make_default_kde "$filename" "$mimetype"
907
 
        make_default_generic "$filename" "$mimetype"
908
 
    done
909
 
    exit_success
910
 
fi
911
 
 
912
 
if [ "$action" = "info" ]; then
913
 
    detectDE
914
 
 
915
 
    if [ x"$DE" = x"" ]; then
916
 
        if [ -x /usr/bin/file ]; then
917
 
            DE=generic
918
 
        fi
919
 
    fi
920
 
 
921
 
    case "$DE" in
922
 
        kde)
923
 
        info_kde "$filename"
924
 
        ;;
925
 
 
926
 
        gnome)
927
 
        info_gnome "$filename"
928
 
        ;;
929
 
 
930
 
        *)
931
 
        info_generic "$filename"
932
 
        ;;
933
 
    esac
934
 
    exit_failure_operation_impossible "no method available for quering MIME type of '$filename'"
935
 
fi
936
 
 
937
 
if [ "$action" = "defapp" ]; then
938
 
    detectDE
939
 
 
940
 
    case "$DE" in
941
 
        kde)
942
 
        defapp_kde "$mimetype"
943
 
        ;;
944
 
 
945
 
        *)
946
 
        defapp_generic "$mimetype"
947
 
        ;;
948
 
    esac
949
 
    exit_failure_operation_impossible "no method available for quering default application for '$mimetype'"
950
 
fi
951
 
 
952
 
vendor=true
953
 
while [ $# -gt 0 ] ; do
954
 
    parm="$1"
955
 
    shift
956
 
 
957
 
    case $parm in
958
 
      --mode)
959
 
        if [ -z "$1" ] ; then
960
 
            exit_failure_syntax "mode argument missing for --mode"
961
 
        fi
962
 
        case "$1" in
963
 
          user)
964
 
            mode="user"
965
 
            ;;
966
 
 
967
 
          system)
968
 
            mode="system"
969
 
            ;;
970
 
 
971
 
          *)
972
 
            exit_failure_syntax "unknown mode '$1'"
973
 
            ;;
974
 
        esac
975
 
        shift
976
 
        ;;
977
 
 
978
 
      --novendor)
979
 
        vendor=false
980
 
        ;;
981
 
 
982
 
      -*)
983
 
        exit_failure_syntax "unexpected option '$parm'"
984
 
        ;;
985
 
 
986
 
      *)
987
 
        if [ -n "$filename" ] ; then
988
 
            exit_failure_syntax "unexpected argument '$parm'"
989
 
        fi
990
 
 
991
 
        filename="$parm"
992
 
        check_input_file "$filename"
993
 
        ;;
994
 
    esac
995
 
done
996
 
 
997
 
if [ -z "$action" ] ; then
998
 
    exit_failure_syntax "command argument missing"
999
 
fi
1000
 
 
1001
 
if [ -n "$XDG_UTILS_INSTALL_MODE" ] ; then
1002
 
    if [ "$XDG_UTILS_INSTALL_MODE" = "system" ] ; then
1003
 
        mode="system"
1004
 
    elif [ "$XDG_UTILS_INSTALL_MODE" = "user" ] ; then
1005
 
        mode="user"
1006
 
    fi
1007
 
fi
1008
 
 
1009
 
if [ -z "$mode" ] ; then
1010
 
    if [ `whoami` = "root" ] ; then
1011
 
        mode="system"
1012
 
    else
1013
 
        mode="user"
1014
 
    fi
1015
 
fi
1016
 
 
1017
 
if [ -z "$filename" ] ; then
1018
 
    exit_failure_syntax "mimetypes-file argument missing"
1019
 
fi
1020
 
 
1021
 
if [ "$vendor" =  "true" -a "$action" = "install" ] ; then
1022
 
    check_vendor_prefix "$filename"
1023
 
fi
1024
 
 
1025
 
xdg_base_dir=
1026
 
xdg_dir_name=mime/packages/
1027
 
 
1028
 
xdg_user_dir="$XDG_DATA_HOME"
1029
 
[ -n "$xdg_user_dir" ] || xdg_user_dir="$HOME/.local/share"
1030
 
[ x"$mode" = x"user" ] && xdg_base_dir="$xdg_user_dir/mime"
1031
 
xdg_user_dir="$xdg_user_dir/$xdg_dir_name"
1032
 
 
1033
 
xdg_system_dirs="$XDG_DATA_DIRS"
1034
 
[ -n "$xdg_system_dirs" ] || xdg_system_dirs=/usr/local/share/:/usr/share/
1035
 
for x in `echo $xdg_system_dirs | sed 's/:/ /g'`; do
1036
 
    if [ -w $x/$xdg_dir_name ] ; then
1037
 
        [ x"$mode" = x"system" ] && xdg_base_dir="$x/mime"
1038
 
        xdg_global_dir="$x/$xdg_dir_name"
1039
 
        break
1040
 
    fi
1041
 
done
1042
 
[ -w $xdg_global_dir ] || xdg_global_dir=
1043
 
DEBUG 3 "xdg_user_dir: $xdg_user_dir"
1044
 
DEBUG 3 "xdg_global_dir: $xdg_global_dir"
1045
 
 
1046
 
# Find KDE3 mimelnk directory
1047
 
kde_user_dir=
1048
 
kde_global_dir=
1049
 
kde_global_dirs=`kde${KDE_SESSION_VERSION}-config --path mime 2> /dev/null`
1050
 
DEBUG 3 "kde_global_dirs: $kde_global_dirs"
1051
 
first=
1052
 
for x in `echo $kde_global_dirs | sed 's/:/ /g'` ; do
1053
 
    if [ -z "$first" ] ; then
1054
 
        first=false
1055
 
        kde_user_dir="$x"
1056
 
    elif [ -w $x ] ; then
1057
 
        kde_global_dir="$x"
1058
 
    fi
1059
 
done
1060
 
DEBUG 3 "kde_user_dir: $kde_user_dir"
1061
 
DEBUG 3 "kde_global_dir: $kde_global_dir"
1062
 
 
1063
 
# TODO: Gnome legacy support
1064
 
# See http://forums.fedoraforum.org/showthread.php?t=26875
1065
 
gnome_user_dir="$HOME/.gnome/apps"
1066
 
gnome_global_dir=/usr/share/gnome/apps
1067
 
[ -w $gnome_global_dir ] || gnome_global_dir=
1068
 
DEBUG 3 "gnome_user_dir: $gnome_user_dir"
1069
 
DEBUG 3 "gnome_global_dir: $gnome_global_dir"
1070
 
 
1071
 
if [ x"$mode" = x"user" ] ; then
1072
 
    xdg_dir="$xdg_user_dir"
1073
 
    kde_dir="$kde_user_dir"
1074
 
    gnome_dir="$gnome_user_dir"
1075
 
    my_umask=077
1076
 
else
1077
 
    xdg_dir="$xdg_global_dir"
1078
 
    kde_dir="$kde_global_dir"
1079
 
    gnome_dir="$gnome_global_dir"
1080
 
    my_umask=022
1081
 
    if [ -z "${xdg_dir}${kde_dir}${gnome_dir}" ] ; then
1082
 
        exit_failure_operation_impossible "No writable system mimetype directory found."
1083
 
    fi
1084
 
fi
1085
 
 
1086
 
# echo "[xdg|$xdg_user_dir|$xdg_global_dir]"
1087
 
# echo "[kde|$kde_user_dir|$kde_global_dir]"
1088
 
# echo "[gnome|$gnome_user_dir|$gnome_global_dir]"
1089
 
# echo "[using|$xdg_dir|$kde_dir|$gnome_dir]"
1090
 
 
1091
 
basefile=`basename "$filename"`
1092
 
#[ -z $vendor ] || basefile="$vendor-$basefile"
1093
 
 
1094
 
mimetypes=
1095
 
if [ -n "$kde_dir" ] ; then
1096
 
    DEBUG 2 "KDE3 mimelnk directory found, extracting mimetypes from XML file"
1097
 
 
1098
 
    mimetypes=`awk < "$filename" '
1099
 
# Strip XML comments
1100
 
BEGIN {
1101
 
 suppress=0
1102
 
}
1103
 
{
1104
 
 do
1105
 
    if (suppress) {
1106
 
       if (match($0,/-->/)) {
1107
 
           $0=substr($0,RSTART+RLENGTH)
1108
 
           suppress=0
1109
 
       }
1110
 
       else {
1111
 
           break
1112
 
       }
1113
 
    }
1114
 
    else {
1115
 
       if (match($0,/<!--/)) {
1116
 
           if (RSTART>1) print substr($0,0,RSTART)
1117
 
           $0=substr($0,RSTART+RLENGTH)
1118
 
           suppress=1
1119
 
       }
1120
 
       else {
1121
 
           if ($0) print $0
1122
 
           break
1123
 
       }
1124
 
    }
1125
 
 while(1)
1126
 
}
1127
 
' | awk '
1128
 
# List MIME types listed in <mime-type> tags
1129
 
BEGIN {
1130
 
  RS="<"
1131
 
}
1132
 
/^mime-info/, /^\/mime-info/ {
1133
 
  if (match($0,/^mime-type/)) {
1134
 
    if (match($0,/type="[^"]*/) || match($0,/type='"'"'[^'"'"']*/)) {
1135
 
      print substr($0,RSTART+6,RLENGTH-6)
1136
 
    }
1137
 
  }
1138
 
}'`
1139
 
fi
1140
 
 
1141
 
DEBUG 1 "$action mimetype in $xdg_dir"
1142
 
 
1143
 
case $action in
1144
 
    install)
1145
 
        save_umask=`umask`
1146
 
        umask $my_umask
1147
 
 
1148
 
        for x in $xdg_dir ; do
1149
 
            mkdir -p $x
1150
 
            eval 'cp $filename $x/$basefile'$xdg_redirect_output
1151
 
        done
1152
 
 
1153
 
        if [ -n "$mimetypes" ] ; then
1154
 
            # No quotes around $mimetypes
1155
 
            for x in $mimetypes ; do
1156
 
                DEBUG 1 "Installing $kde_dir/$x.desktop (KDE 3.x support)"
1157
 
                mkdir -p `dirname $kde_dir/$x.desktop`
1158
 
                awk < "$filename" '
1159
 
# Strip XML comments
1160
 
BEGIN {
1161
 
 suppress=0
1162
 
}
1163
 
{
1164
 
 do
1165
 
    if (suppress) {
1166
 
       if (match($0,/-->/)) {
1167
 
           $0=substr($0,RSTART+RLENGTH)
1168
 
           suppress=0
1169
 
       }
1170
 
       else {
1171
 
           break
1172
 
       }
1173
 
    }
1174
 
    else {
1175
 
       if (match($0,/<!--/)) {
1176
 
           if (RSTART>1) print substr($0,0,RSTART)
1177
 
           $0=substr($0,RSTART+RLENGTH)
1178
 
           suppress=1
1179
 
       }
1180
 
       else {
1181
 
           if ($0) print $0
1182
 
           break
1183
 
       }
1184
 
    }
1185
 
 while(1)
1186
 
}
1187
 
' | awk > $kde_dir/$x.desktop '
1188
 
# Extract mimetype $x from the XML file $filename
1189
 
# Note that bash requires us to escape a single quote as '"'"'
1190
 
BEGIN {
1191
 
  the_type=ARGV[1]
1192
 
  the_source=ARGV[2]
1193
 
  ARGC=1
1194
 
  RS="<"
1195
 
  found=0
1196
 
  glob_patterns=""
1197
 
}
1198
 
/^mime-info/, /^\/mime-info/ {
1199
 
  if (match($0,/^mime-type/)) {
1200
 
    if (match($0,/type="[^"]*/) || match($0,/type='"'"'[^'"'"']*/)) {
1201
 
      if (substr($0,RSTART+6,RLENGTH-6) == the_type) {
1202
 
        found=1
1203
 
        print "[Desktop Entry]"
1204
 
        print "# Installed by xdg-mime from " the_source
1205
 
        print "Type=MimeType"
1206
 
        print "MimeType=" the_type
1207
 
        the_icon=the_type
1208
 
        sub("/", "-", the_icon)
1209
 
        print "Icon=" the_icon
1210
 
      }
1211
 
    }
1212
 
  }
1213
 
  else if (found) {
1214
 
    if (match($0,/^\/mime-type/)) {
1215
 
      if (glob_patterns)
1216
 
         print "Patterns=" glob_patterns
1217
 
      exit 0
1218
 
    }
1219
 
 
1220
 
    if (match($0,/^sub-class-of/)) {
1221
 
      if (match($0,/type="[^"]*/) || match($0,/type='"'"'[^'"'"']*/)) {
1222
 
        print "X-KDE-IsAlso=" substr($0,RSTART+6,RLENGTH-6)
1223
 
      }
1224
 
      else {
1225
 
        print "Error: '"'"'type'"'"' argument missing in " RS $0
1226
 
        exit 1
1227
 
      }
1228
 
    }
1229
 
    if (match($0,/^glob/)) {
1230
 
      if (match($0,/pattern="[^"]*/) || match($0,/pattern='"'"'[^'"'"']*/)) {
1231
 
        glob_patterns = glob_patterns substr($0,RSTART+9,RLENGTH-9) ";"
1232
 
      }
1233
 
      else {
1234
 
        print "Error: '"'"'pattern'"'"' argument missing in " RS $0
1235
 
        exit 1
1236
 
      }
1237
 
    }
1238
 
    if (match($0,/^comment/)) {
1239
 
      if (match($0,/xml:lang="[^"]*/) || match($0,/xml:lang='"'"'[^'"'"']*/)) {
1240
 
        lang=substr($0,RSTART+10,RLENGTH-10)
1241
 
      }
1242
 
      else {
1243
 
        lang=""
1244
 
      }
1245
 
      if (match($0,/>/)) {
1246
 
        comment=substr($0,RSTART+1)
1247
 
        sub("&lt;", "<", comment)
1248
 
        sub("&gt;", ">", comment)
1249
 
        sub("&amp;", "\\&", comment)
1250
 
        if (lang)
1251
 
           print "Comment[" lang "]=" comment
1252
 
        else
1253
 
           print "Comment=" comment
1254
 
      }
1255
 
    }
1256
 
  }
1257
 
}
1258
 
END {
1259
 
  if (!found) {
1260
 
    print "Error: Mimetype '"'"'" the_type "'"'"' not found"
1261
 
    exit 1
1262
 
  }
1263
 
}
1264
 
' $x $basefile
1265
 
                if [ "$?" = "1" ] ; then
1266
 
                    grep -A 10 "^Error:" $kde_dir/$x.desktop >&2
1267
 
                    rm $kde_dir/$x.desktop
1268
 
                    exit 1
1269
 
                fi
1270
 
            done
1271
 
        fi
1272
 
 
1273
 
        umask $save_umask
1274
 
        ;;
1275
 
 
1276
 
    uninstall)
1277
 
        for x in $xdg_dir ; do
1278
 
            rm -f $x/$basefile
1279
 
        done
1280
 
 
1281
 
        # No quotes around $mimetypes
1282
 
        for x in $mimetypes ; do
1283
 
            if grep '^# Installed by xdg-mime' $kde_dir/$x.desktop >/dev/null 2>&1; then
1284
 
                DEBUG 1 "Removing $kde_dir/$x.desktop (KDE 3.x support)"
1285
 
                rm -f $kde_dir/$x.desktop
1286
 
            fi
1287
 
        done
1288
 
        ;;
1289
 
esac
1290
 
 
1291
 
update_mime_database $xdg_base_dir
1292
 
 
1293
 
exit_success
1294