summaryrefslogtreecommitdiffstats
path: root/startkde
blob: 72a100b1b4a4591b475a2d836a3758224033b770 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
#!/bin/sh
#
#  DEFAULT TRINITY STARTUP SCRIPT ( KDE-3.5.12 )
#

echo "[startkde] Starting startkde." 1>&2

# When the X server dies we get a HUP signal from xinit. We must ignore it
# because we still need to do some cleanup.
trap '[startkde] echo GOT SIGHUP' HUP

# Check if a KDE session is already running.
if kcheckrunning >/dev/null 2>&1; then
	echo "[startkde] KDE seems to be already running on this display."
	xmessage -geometry 500x100 "KDE seems to be already running on this display." > /dev/null 2>/dev/null
	exit 1
fi

# Set the background color.
# The standard X background is nasty, causing moire effects and exploding
# people's heads. We use colours from the standard KDE palette for those with
# palettised displays.
if test -z "$XDM_MANAGED" || echo "$XDM_MANAGED" | grep ",auto" > /dev/null; then
  xsetroot -solid "#618DCC" # sky blue
fi

# Unset this for Darwin since it will screw up KDE's dynamic-loading
unset DYLD_FORCE_FLAT_NAMESPACE

# Check whether prelinking is enabled. If so, exporting KDE_IS_PRELINKED improves
# loading KDE. The $KDE_IS_PRELINKED variable might already be set on some systems
# through /etc/profile.d, so first check whether the variable exists.
if [ -z $KDE_IS_PRELINKED ]; then
  if [ -r /etc/default/prelink ]; then
    . /etc/default/prelink
    if [ "$PRELINKING" == "yes" ]; then
      export KDE_IS_PRELINKED=1
    fi
  fi
fi

# In case we have been started with full pathname spec without being in PATH.
bindir=`echo "$0" | sed -n 's,^\(/.*\)/[^/][^/]*$,\1,p'`
if [ -n "$bindir" ]; then
  case $PATH in
    $bindir|$bindir:*|*:$bindir|*:$bindir:*) ;;
    *) PATH=$bindir:$PATH; export PATH;;
  esac
fi

# Boot sequence:
#
# kdeinit is used to fork off processes which improves memory usage
# and startup time.
#
# * kdeinit starts the dcopserver and klauncher first.
# * Then kded is started. kded is responsible for keeping the sycoca
#   database up to date. When an up to date database is present it goes
#   into the background and the startup continues.
# * Then kdeinit starts kcminit. kcminit performs initialisation of
#   certain devices according to the user's settings
#
# * Then ksmserver is started which takes control of the rest of the startup sequence

# The user's personal KDE directory usually is $HOME/.kde or $HOME/.kde3.
# This setting may be overridden by setting $KDEHOME.
# Must be careful here because $HOME/.kde was used commonly in the pre-KDE4
# days for the user's KDE3 profile, but now with KDE4 common on systems,
# $HOME/.kde might point to KDE4 profile settings. Further, the existence
# of KDE4 does not mean all people have KDE4 installed and might want to keep
# $HOME/.kde as their preferred profile location for Trinity KDE.

if [ -n "$KDEHOME" ]; then
  echo "[startkde] KDEHOME is preset to $KDEHOME." 1>&2
  export KDEHOME=$KDEHOME
else
  # $KDEHOME is NOT already preset in the environment. Try to help.
  # This might be overkill but does provide flexibility.
  echo "[startkde] KDEHOME is not set." 1>&2
  if [ -d $HOME/.kde3 ]; then
    # OK, this one is obvious.
    export KDEHOME=$HOME/.kde3
  elif [ -f /usr/bin/kde4-config ]; then
    # Looks like KDE4 is installed.
    if [ -d $HOME/.kde ] && [ ! -d $HOME/.kde3 ]; then
      # Presume $HOME/.kde is being used for KDE4 as it already exists.
      export KDEHOME=$HOME/.kde3
    else
      # Presume $HOME/.kde is being used for KDE4 to be on the safe side.
      export KDEHOME=$HOME/.kde3
    fi
  elif [ -f /opt/kde3/bin/kde-config ]; then
    # Looks like KDE3 or Trinity is installed and playing second fiddle to KDE4.
    export KDEHOME=$HOME/.kde3
  elif [ -f /opt/kde3/bin/kde-config ]; then
    # Looks like KDE3 or Trinity is installed and playing second fiddle to KDE4.
    export KDEHOME=$HOME/.kde3
  elif [ -f /usr/bin/kde-config ] && [ -d $HOME/.kde ]; then
    # Looks like KDE3 or Trinity is installed and not playing second fiddle to KDE4.
    export KDEHOME=$HOME/.kde
  else
    # Resort to this and hope for the best!
    export KDEHOME=$HOME/.kde3
  fi
  echo "[startkde] Set KDEHOME to $KDEHOME." 1>&2
fi

# Run a quick test for root.
if [ -z "$KDEROOTHOME" ] && [ "$UID" = "0" ]; then
  echo "[startkde] User ID is $UID. Setting KDEROOTHOME to $KDEHOME."
  export KDEROOTHOME=$KDEHOME
fi

# Modify the following environment variables only as necessary.
if [ -d /opt/kde3/games ]; then
  export PATH=/opt/kde3/games:$PATH
fi
if [ -d /opt/kde3/bin ]; then
  export PATH=/opt/kde3/bin:$PATH
fi
if [ -d /opt/trinity/games ]; then
  export PATH=/opt/trinity/games:$PATH
fi
if [ -d /opt/trinity/bin ]; then
  export PATH=/opt/trinity/bin:$PATH
fi
if [ -d /opt/kde3/share ]; then
  export XDG_DATA_DIRS=$XDG_DATA_DIRS:/opt/kde3/share/:/usr/share/
fi
if [ -d /opt/trinity/share ]; then
  export XDG_DATA_DIRS=$XDG_DATA_DIRS:/opt/trinity/share/:/usr/share/
fi
if [ -d /opt/kde3/etc/xdg ]; then
  export XDG_CONFIG_DIRS=$XDG_CONFIG_DIRS:/opt/kde3/etc/xdg/:/etc/xdg/
fi
if [ -d /opt/trinity/etc/xdg ]; then
  export XDG_CONFIG_DIRS=$XDG_CONFIG_DIRS:/opt/trinity/etc/xdg/:/etc/xdg/
fi
if [ -d /opt/kde3/share/man ]; then
  export MANPATH=/opt/kde3/share/man:$MANPATH
fi
if [ -d /opt/trinity/share/man ]; then
  export MANPATH=/opt/trinity/share/man:$MANPATH
fi
if [ -d /opt/kde3 ]; then
  if [ -n "$KDEDIRS" ]; then
    export KDEDIRS=$KDEDIRS:/opt/kde3/:/usr/
  else
    export KDEDIRS=/opt/kde3/:/usr/
  fi
fi
if [ -d /opt/trinity ]; then
  if [ -n "$KDEDIRS" ]; then
    export KDEDIRS=$KDEDIRS:/opt/trinity/:/usr/
  else
    export KDEDIRS=/opt/trinity/:/usr/
  fi
fi

test -n "$KDEHOME" && kdehome=`echo "$KDEHOME" | sed "s,^~/,$HOME/,"`
echo "[startkde] kdehome: $kdehome" 1>&2

# Allow interested applications, such as the Plasma control wrapper,
# to know that this is a Trinity desktop and not a KDE one.
export DESKTOP_SESSION=kde3

# Please see kstartupconfig source for usage.
mkdir -m 700 -p $kdehome
mkdir -m 700 -p $kdehome/share
mkdir -m 700 -p $kdehome/share/config
cat >$kdehome/share/config/startupconfigkeys <<EOF
kcminputrc Mouse cursorTheme ''
kcminputrc Mouse cursorSize ''
kpersonalizerrc General FirstLogin true
ksplashrc KSplash Theme Default
kcmrandrrc Display ApplyOnStartup false
kcmrandrrc [Screen0]
kcmrandrrc [Screen1]
kcmrandrrc [Screen2]
kcmrandrrc [Screen3]
kcmfonts General forceFontDPI 0
EOF
kstartupconfig
if test $? -ne 0; then
  xmessage -geometry 500x100 "Could not start kstartupconfig. Check your installation."
fi
# $kdehome/share/config/startupconfig should exist but avoid script failure if not.
if [ -r $kdehome/share/config/startupconfig ]; then
  . $kdehome/share/config/startupconfig
fi

# Make sure a default wallpaper is set.
if [ ! -e $kdehome/share/config/kdesktoprc ]; then
 # With Trinity KDE this file should exist, but test first.
  if [ -r /usr/share/wallpapers/isadora.png.desktop ]; then
cat >$kdehome/share/config/kdesktoprc <<EOF
[Desktop0]
Wallpaper=isadora.png
WallpaperMode=Scaled
EOF
  fi
fi

# XCursor mouse theme needs to be applied here to work even for kded or ksmserver.
if test -n "$kcminputrc_mouse_cursortheme" -o -n "$kcminputrc_mouse_cursorsize" ; then
    kapplymousetheme "$kcminputrc_mouse_cursortheme" "$kcminputrc_mouse_cursorsize"
    if test $? -eq 10; then
        export XCURSOR_THEME=default
    elif test -n "$kcminputrc_mouse_cursortheme"; then
        export XCURSOR_THEME="$kcminputrc_mouse_cursortheme"
    fi
    if test -n "$kcminputrc_mouse_cursorsize"; then
        export XCURSOR_SIZE="$kcminputrc_mouse_cursorsize"
    fi
fi

if test "$kcmrandrrc_display_applyonstartup" = "true"; then
    # 4 screens is hopefully enough
    for scrn in 0 1 2 3; do
        args=
        width="\$kcmrandrrc_screen${scrn}_width" ; eval "width=$width"
        height="\$kcmrandrrc_screen${scrn}_height" ; eval "height=$height"
        if test -n "${width}" -a -n "${height}"; then
            args="$args -s ${width}x${height}"
        fi
        refresh="\$kcmrandrrc_screen${scrn}_refresh" ; eval "refresh=$refresh"
        if test -n "${refresh}"; then
            args="$args -r ${refresh}"
        fi
        rotation="\$kcmrandrrc_screen${scrn}_rotation" ; eval "rotation=$rotation"
        if test -n "${rotation}"; then
            case "${rotation}" in
                0)
                    args="$args -o 0"
                    ;;
                90)
                    args="$args -o 1"
                    ;;
                180)
                    args="$args -o 2"
                    ;;
                270)
                    args="$args -o 3"
                    ;;
            esac
        fi
        reflectx="\$kcmrandrrc_screen${scrn}_reflectx" ; eval "reflectx=$reflectx"
        if test "${refrectx}" = "true"; then
            args="$args -x"
        fi
        reflecty="\$kcmrandrrc_screen${scrn}_reflecty" ; eval "reflecty=$reflecty"
        if test "${refrecty}" = "true"; then
            args="$args -y"
        fi
        if test -n "$args"; then
            xrandr $args
        fi
    done
fi

dl=$DESKTOP_LOCKED
unset DESKTOP_LOCKED # Don't want it in the environment

# Launch splash that doesn't need any KDE libraries here, before
# KDE libraries are loaded into memory (which may take some time
# with cold caches). Makes the splash appear sooner.
# If kpersonalizer needs to be run splash will be started only later.
if test -z "$dl" && test "$kpersonalizerrc_general_firstlogin" != "true"; then
    case "$ksplashrc_ksplash_theme" in
      Simple)
         ksplashsimple
         ;;
      *)
         ;;
    esac
fi

if test "$kcmfonts_general_forcefontdpi" -eq 120; then
    xrdb -quiet -merge -nocpp <<EOF
Xft.dpi: 120
EOF
elif test "$kcmfonts_general_forcefontdpi" -eq 96; then
    xrdb -quiet -merge -nocpp <<EOF
Xft.dpi: 96
EOF
fi

# Configuration of the gtk_qt_engine if not already set.

if test -n "$KDEDIRS"; then
  kdedirs_first=`echo "$KDEDIRS" | sed -e 's/:.*//'`
  KGTK_RC_ENGINE=$kdedirs_first/share/kgtk/gtk-qt-engine.rc.sh
  KGTK_RC_KDE1=$kdedirs_first/share/kgtk/.gtkrc-2.0-kde4
  KGTK_RC_KDE2=$kdedirs_first/share/kgtk/.gtkrc-2.0-kde-kde4
else
  KGTK_RC_ENGINE=$KDEDIR/share/kgtk/gtk-qt-engine.rc.sh
  KGTK_RC_KDE1=$KDEDIR/share/kgtk/.gtkrc-2.0-kde4
  KGTK_RC_KDE2=$KDEDIR/share/kgtk/.gtkrc-2.0-kde-kde4
fi

if [ ! -e $kdehome/env/gtk-qt-engine.rc.sh ] && [ -e $KGTK_RC_ENGINE ]
then
 mkdir -p $kdehome/env
 cp -f $KGTK_RC_ENGINE $kdehome/env
 chmod 755 $kdehome/env/gtk-qt-engine.rc.sh
fi

if [ ! -e $HOME/.gtkrc-2.0-kde4 ] && [ -e $KGTK_RC_KDE1 ]
then
 cp -f $KGTK_RC_KDE1 $HOME
fi

if [ ! -e $HOME/.gtkrc-2.0-kde-kde4 ] && [ -e $KGTK_RC_KDE2 ]
then
 cp -f $KGTK_RC_KDE2 $HOME
fi

# Source scripts found in <localprefix>/env/*.sh and <prefixes>/env/*.sh
# (where <localprefix> is $KDEHOME or ~/.kde3, and <prefixes> is where KDE is installed)
#
# This is where you can define environment variables that will be available to
# all KDE programs, so this is where you can run agents using e.g. eval `ssh-agent`
# or eval `gpg-agent --daemon`.
# Note: if you do that, you should also put "ssh-agent -k" as a shutdown script
#
# (see end of this file).
# For anything else (that doesn't set env vars, or that needs a window manager),
# better use the Autostart folder.

exepath=`kde-config --path exe | tr : '\n'`

for prefix in `echo "$exepath" | sed -n -e 's,/bin[^/]*/,/env/,p'`; do
  for file in "$prefix"*.sh; do
    test -r "$file" && . "$file"
  done
done

# Activate the kde font directories.
#
# There are 4 directories that may be used for supplying fonts for KDE.
#
# There are two system directories. These belong to the administrator.
# There are two user directories, where the user may add her own fonts.
#
# The 'override' versions are for fonts that should come first in the list,
# i.e. if you have a font in your 'override' directory, it will be used in
# preference to any other.
#
# The preference order looks like this:
# user override, system override, X, user, system
#
# Where X is the original font database that was set up before this script
# runs.

usr_odir=$HOME/.fonts/kde-override
usr_fdir=$HOME/.fonts

# Add any user-installed font directories to the X font path
kde_fontpaths=$usr_fdir/fontpaths
do_usr_fdir=1
do_usr_odir=1
if test -r "$kde_fontpaths" ; then
    savifs=$IFS
    IFS="
"
    for fpath in `grep -v '^[ 	]*#' < "$kde_fontpaths"` ; do
        rfpath=`echo $fpath | sed "s:^~:$HOME:g"`
        if test -s "$rfpath"/fonts.dir; then
            xset fp+ "$rfpath"
            if test "$rfpath" = "$usr_fdir"; then
                do_usr_fdir=0
            fi
            if test "$rfpath" = "$usr_odir"; then
                do_usr_odir=0
            fi
        fi
    done
    IFS=$savifs
fi

if [ ! -n "$KDEDIR" ]; then
  export KDEDIR=`echo "$KDEDIRS" | sed -e 's/:.*//'`
fi

echo "[startkde] KDEDIR: $KDEDIR" 1>&2
echo "[startkde] KDEDIRS: $KDEDIRS" 1>&2

if test -n "$KDEDIRS"; then
  kdedirs_first=`echo "$KDEDIRS" | sed -e 's/:.*//'`
  sys_odir=$kdedirs_first/share/fonts/override
  sys_fdir=$kdedirs_first/share/fonts
else
  sys_odir=$KDEDIR/share/fonts/override
  sys_fdir=$KDEDIR/share/fonts
fi

if test -n "$KDEDIRS"; then
  kdedirs_first=`echo "$KDEDIRS" | sed -e 's/:.*//'`
  echo "[startkde] kdedirs_first: $kdedirs_first"
  if [ -r $kdedirs_first/share/kgtk/preload ]; then
    echo "[startkde] Reading from $kdedirs_first/share/kgtk/preload"
    read -r KGTK_PRELOAD < $kdedirs_first/share/kgtk/preload
  fi
else
  if [ -r $KDEDIR/share/kgtk/preload ]; then
    read -r KGTK_PRELOAD < $KDEDIR/share/kgtk/preload
  fi
fi

if [ -n $KGTK_PRELOAD ]; then
  export LD_PRELOAD=$KGTK_PRELOAD:$LD_PRELOAD
fi

# We run mkfontdir on the user's font dirs (if we have permission) to pick
# up any new fonts they may have installed. If mkfontdir fails, we still
# add the user's dirs to the font path, as they might simply have been made
# read-only by the administrator, for whatever reason.

# Only do usr_fdir and usr_odir if they are *not* listed in fontpaths
if [ -e $sys_odir/fonts.dir ]
then
  xset +fp "$sys_odir"
fi
test $do_usr_odir -eq 1 && test -d "$usr_odir" && (mkfontdir "$usr_odir" ; xset +fp "$usr_odir")
test $do_usr_fdir -eq 1 && test -d "$usr_fdir" && (mkfontdir "$usr_fdir" ; xset fp+ "$usr_fdir")
test -d "$sys_fdir" && xset fp+ "$sys_fdir"

# Ask X11 to rebuild its font list.
xset fp rehash

# Set a left cursor instead of the standard X11 "X" cursor, since I've heard
# from some users that they're confused and don't know what to do. This is
# especially necessary on slow machines, where starting KDE takes one or two
# minutes until anything appears on the screen.
#
# If the user has overwritten fonts, the cursor font may be different now
# so don't move this up.
#
xsetroot -cursor_name left_ptr

# Get Ghostscript to look into user's KDE fonts dir for additional Fontmap
if test -n "$GS_LIB" ; then
  GS_LIB=$usr_fdir:$GS_LIB
  export GS_LIB
else
  GS_LIB=$usr_fdir
  export GS_LIB
fi

# Link "tmp" "socket" and "cache" resources to directory in /tmp
# Creates:
# - a directory /tmp/kde-$USER and links $KDEHOME/tmp-$HOSTNAME to it.
# - a directory /tmp/ksocket-$USER and links $KDEHOME/socket-$HOSTNAME to it.
# - a directory /var/tmp/kdecache-$USER and links $KDEHOME/cache-$HOSTNAME to it.
# Note: temporary locations can be overriden through the KDETMP and KDEVARTMP
# environment variables.
for resource in tmp cache socket; do
  if ! lnusertemp $resource >/dev/null; then
    echo "[startkde] Call to lnusertemp failed (temporary directories full?). Check your installation." 1>&2
    xmessage -geometry 600x100 "Call to lnusertemp failed (temporary directories full?). Check your installation."
    exit 1
  fi
done

# In case of dcop sockets left by a previous session, cleanup.
dcopserver_shutdown

echo '[startkde] Starting Trinity...'  1>&2

# Run KPersonalizer before the session if this is the first login.
if test "$kpersonalizerrc_general_firstlogin" = "true"; then
  if [ ! -x $KDEDIR/bin/kpersonalizer ]; then
    echo "[startkde] kpersonalizer not found! Please install it in order to properly configure your user profile." 1>&2
  else
    # start only dcopserver, don't start whole kdeinit (takes too long)
    echo "[startkde] Running kpersonalizer..." 1>&2
    dcopserver
    kwin --lock &
    kpersonalizer --before-session
    # handle kpersonalizer restarts (language change)
    while test $? -eq 1; do
        kpersonalizer --r --before-session
    done
    dcopquit kwin
    dcopserver_shutdown --wait
  fi
fi

# Remove moodin cache if we have a new wallpaper installed, jriddell. Distro-specific.
if [ -d $kdehome/share/apps/ksplash/cache/Moodin/kubuntu ]; then
  if [ /usr/share/wallpapers/kubuntu-wallpaper.png -nt $kdehome/share/apps/ksplash/cache/Moodin/kubuntu/ ]; then
    rm -rf $kdehome/share/apps/ksplash/cache/Moodin/kubuntu/
  fi
fi

if test -z "$dl"; then
  # the splashscreen and progress indicator
  case "$ksplashrc_ksplash_theme" in
    None)
       ;; # nothing
    Simple)
       if test "$kpersonalizerrc_general_firstlogin" = "true"; then
           ksplashsimple
       fi # otherwise started earlier
       ;;
    *)
       ksplash --nodcop
       ;;
  esac
fi

# Mark that full KDE session is running (e.g. Konqueror preloading works only
# with full KDE running). The KDE_FULL_SESSION property can be detected by
# any X client connected to the same X session, even if not launched
# directly from the KDE session but e.g. using "ssh -X", kdesu. $KDE_FULL_SESSION
# however guarantees that the application is launched in the same environment
# like the KDE session and that e.g. KDE utilities/libraries are available.
# KDE_FULL_SESSION property is also only available since KDE 3.5.5.
# The matching tests are:
#   For $KDE_FULL_SESSION:
#     if test -n "$KDE_FULL_SESSION"; then ... whatever
#   For KDE_FULL_SESSION property:
#     xprop -root | grep "^KDE_FULL_SESSION" >/dev/null 2>/dev/null
#     if test $? -eq 0; then ... whatever
#
# Additionally there is (since KDE 3.5.7) $KDE_SESSION_UID with the uid
# of the user running the KDE session. It should be rarely needed (e.g.
# after sudo to prevent desktop-wide functionality in the new user's kded).
#
KDE_FULL_SESSION=true
export KDE_FULL_SESSION
xprop -root -f KDE_FULL_SESSION 8t -set KDE_FULL_SESSION true
echo "[startkde] KDE_FULL_SESSION: $KDE_FULL_SESSION" 1>&2
KDE_SESSION_UID=$UID
export KDE_SESSION_UID
echo "[startkde] KDE_SESSION_UID: $KDE_SESSION_UID" 1>&2

# We set LD_BIND_NOW to increase the efficiency of kdeinit.
# kdeinit unsets this variable before loading applications.
LD_BIND_NOW=true start_kdeinit_wrapper --new-startup +kcminit_startup
if test $? -ne 0; then
  # Startup error
  echo '[startkde] Could not start kdeinit. Check your installation.' 1>&2
  xmessage -geometry 500x100 "Could not start kdeinit. Check your installation."
fi
echo "[startkde] kdeinit started successfully." 1>&2

# If the session should be locked from the start (locked autologin),
# lock now and do the rest of the KDE startup underneath the locker.
if test -n "$dl"; then
  kwrapper kdesktop_lock --forcelock &
  # Give it some time for starting up. This is somewhat unclean; some
  # notification would be better.
  sleep 1
fi

# Finally, give the session control to the session manager.
# See kdebase/ksmserver for the description of the rest of the startup sequence.
# If the KDEWM environment variable has been set, then it will be used as Trinity's
# window manager instead of kwin.
# If KDEWM is not set, ksmserver will ensure kwin is started.
# kwrapper is used to reduce startup time and memory usage
# kwrapper does not return usefull error codes such as the exit code of ksmserver.
# We only check for 255 which means that the ksmserver process could not be
# started, any problems thereafter, e.g. ksmserver failing to initialize,
# will remain undetected.
test -n "$KDEWM" && KDEWM="--windowmanager $KDEWM"
kwrapper ksmserver $KDEWM
if test $? -eq 255; then
  # Startup error
  echo '[startkde] Could not start ksmserver. Check your installation.' 1>&2
  xmessage -geometry 500x100 "Could not start ksmserver. Check your installation."
fi

# wait if there's any crashhandler shown
while dcop | grep -q ^drkonqi- ; do
    sleep 5
done

echo '[startkde] Shutting down Trinity...'  1>&2

# Clean up
kdeinit_shutdown
dcopserver_shutdown --wait
artsshell -q terminate
# KDE4 support
if [ -f /usr/bin/kdeinit4_shutdown ]; then
  kde4 kdeinit4_shutdown 2>/dev/null
fi

echo '[startkde] Running Trinity shutdown scripts...'  1>&2

# Run scripts found in $KDEDIRS/shutdown
for prefix in `echo "$exepath" | sed -n -e 's,/bin[^/]*/,/shutdown/,p'`; do
  for file in `ls "$prefix" 2> /dev/null | egrep -v '(~|\.bak)$'`; do
    if [ -x "${prefix}${file}" ]; then
      echo "[startkde] Running ${prefix}${file}." 1>&2
      sh ${prefix}${file}
    fi
  done
done

unset KDE_FULL_SESSION
xprop -root -remove KDE_FULL_SESSION
unset KDE_SESSION_UID

# Initialize_Status_Header
echo "[startkde] Trinity shutdown complete." 1>&2