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

« back to all changes in this revision

Viewing changes to .pc/lp779156-lubuntu.diff/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