summaryrefslogtreecommitdiffstats
path: root/startkde
blob: 92b2e3618182c5d476a613abf91fc72bfc471d74 (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
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
#!/bin/sh
#
#  DEFAULT TRINITY STARTUP SCRIPT
#

# This block may not be appropriate for all systems.
# It should work for command line logins but graphical
# login managers may source these files already.
# Multiple sourcing is not a problem when the files are only
# containers for environment variables and such.
if [ -r /etc/xprofile ]; then
  source /etc/xprofile
fi
if [ -r $HOME/.xprofile ]; then
  source $HOME/.xprofile
fi

# Some functions to parse and check path correctly ...
# Usage: is_in_path PATH /usr/bin
is_in_path() {
  var="$1"; search="$2";
  if eval test -z \$$1; then return 1; fi
  ifs="$IFS"; IFS=":"; eval set \$$var; IFS="$ifs"
  for i in $*; do
    [ "${i}" = "${search}" ] && return 0
  done
  return 1
}

# Usage: place_before_in_path PATH /opt/trinity/games /usr/games
place_before_in_path() {
  var="$1"; insert="$2";
  if eval test -z \$$1; then
    eval export $var=${insert}
  else
    before="$3"; ifs="$IFS"; IFS=":"; eval set \$$var; IFS="$ifs"
    NPATH=""
    for i in $*; do
      [ "${i}" = "${before}" ] && NPATH="${NPATH}:${insert}"
      NPATH="${NPATH}:${i}"
    done
    eval export $var=${NPATH#:}
  fi
}

# Usage: remove_from_path PATH /opt/trinity/games
remove_from_path() {
  var="$1"; remove="$2";
  if eval test -z \$$1; then return 1; fi
  ifs="$IFS"; IFS=":"; eval set \$$var; IFS="$ifs"
  NPATH=""
  for i in $*; do
    [ "${i}" != "${remove}" ] && NPATH="${NPATH}:${i}"
  done
  eval export $var=${NPATH#:}
}

echo "[startkde] Starting startkde." 1>&2
echo "[startkde] This script is $0" 1>&2

# Avoid any possible conflict with KDE4. Therefore within this script
# use full path names to all binaries used.

# The binaries for TDE are located in the same place as this script.
# To determine that location use the following method rather than presuming
# the existence of $KDEDIR. That environment variable might not be
# defined or defined to point to KDE4 binaries.
BIN_DIR="`dirname \`readlink -f $0\``"
# Do not use kde-config to determine the version. That command creates a
# profile directory in the root of the file system. Refer to Bug Report 293.
if [ -x $BIN_DIR/konqueror ]; then
  KDE_VERSION=$($BIN_DIR/konqueror --version | while IFS=: read a b; do [ "${a#KDE}" != "$a" ] && echo $b; done)
  echo "[startkde] TDE version is $KDE_VERSION" 1>&2
  export KDEDIR=${BIN_DIR%/bin}
  echo "[startkde] TDE base directory is $KDEDIR" 1>&2
else
  echo "[startkde] Unable to determine TDE base directory."
  echo "[startkde] This script should be installed in the same directory."
  echo "[startkde] Exiting."
  exit 1
fi
unset BIN_DIR

# KDEDIRS
if is_in_path KDEDIRS "/usr" && ! is_in_path KDEDIRS "${KDEDIR}"; then
  echo "[startkde] KDEDIRS is currently set to: ${KDEDIRS}" 1>&2
  echo "[startkde] Adding KDEDIR in KDEDIRS" 1>&2
  place_before_in_path KDEDIRS "${KDEDIR}" "/usr"
fi

# 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 TDE session is already running.
if kcheckrunning >/dev/null 2>&1; then
  echo "[startkde] TDE seems to be already running on this display."
  xmessage -center -geometry 500x100 "TDE 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 TDE 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 TDE's dynamic-loading
unset DYLD_FORCE_FLAT_NAMESPACE

# Check whether prelinking is enabled. If so, exporting KDE_IS_PRELINKED improves
# loading TDE. The $KDE_IS_PRELINKED variable might already be set on some systems
# through /etc/profile.d, so first check whether the variable exists.
if [ "$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

# 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 TDE directory usually is $HOME/.trinity.
# This setting may be overridden by setting $KDEHOME. When migrating profiles
# must be careful here because $HOME/.kde was used commonly in the pre-KDE4
# days for the user's TDE profile, but now with KDE4 common on systems,
# $HOME/.kde might point to KDE4 profile settings. The existence of KDE4
# does not mean all people are using KDE4.

if [ "$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.
  # This script and kstandardirs.h and kstandardirs.cpp must match.
  # The latter two must be edited/patched before compiling.
  echo "[startkde] KDEHOME is not set." 1>&2
  # Default value: $HOME/.trinity. Most users will use this.
  export KDEHOME=$HOME/.trinity

  if [ ! -d $HOME/.trinity ] && [ ! -f /usr/bin/kde4-config ] && [ "$KDEDIR"="/usr" ] && [ -d $HOME/.kde ]; then
    # Looks like Trinity is installed and not playing second fiddle to KDE4.
    export KDEHOME=$HOME/.kde
  fi
  echo "[startkde] Set KDEHOME to $KDEHOME." 1>&2
fi

# Do we want to run this script from here in such an automated manner?
# Or leave the script to be run only at the user's discretion?
# The migratekde3 script as written (in draft) requires user intervention,
# which to succeed in TDE needs something like KDialog. Refer to the
# commentary in migratekde3 for more details.
# if [ -x $KDEDIR/migratekde3 ]; then
#   sh $KDEDIR/migratekde3
# fi

# kdesu needs something to find root's TDE profile. Set the KDEROOTHOME variable
# here as last resort. /root/.trinity is a safe presumption. If an admin wants
# a different location then set the KDEROOTHOME variable elsewhere.
if [ "$KDEROOTHOME" = "" ]; then
  export KDEROOTHOME=/root/.trinity
  echo "[startkde] Setting KDEROOTHOME to $KDEROOTHOME."
fi

# Modify the following environment variables only as necessary.
if [ -d $KDEDIR/games ]; then
  if ! is_in_path PATH "$KDEDIR/games" ; then
    # Respect the traditional path order. Don't blindly place $KDEDIR/games
    # first in the path. Only place $KDEDIR/games before /usr/games. If packagers
    # are adding $KDEDIR/games elsewhere, then they need to ensure the traditional
    # search patch is respected.
    # Is there a way we can check that $KDEDIR/games is always placed only just before
    # /usr/games in the search path?
    if is_in_path PATH "/usr/games"; then
      place_before_in_path PATH "$KDEDIR/games" "/usr/games"
    else
      export PATH=$KDEDIR/games:$PATH
    fi
  fi
fi
if [ -d $KDEDIR/bin ]; then
  if ! is_in_path PATH "$KDEDIR/bin" ]; then
    # Respect the traditional path order. Don't blindly place $KDEDIR/bin
    # first in the path. Only place $KDEDIR/bin before /usr/bin. This order is
    # consistent with kdelibs/kdesu/stub.cpp. If packagers are adding $KDEDIR/bin
    # elsewhere, then they need to ensure the traditional search patch is respected.
    # Is there a way we can check that $KDEDIR/bin is always placed only just before
    # /usr/bin in the search path?
    if is_in_path PATH "/usr/bin"; then
      place_before_in_path PATH "$KDEDIR/bin" "/usr/bin"
    else
      export PATH=$KDEDIR/bin:$PATH
    fi
  fi
fi
if [ -d $KDEDIR/share/man ]; then
  if [ -x /usr/bin/manpath ]; then
    if [ "`manpath 2>/dev/null | grep \"$KDEDIR/share/man\"`" = "" ]; then
      export MANPATH=$KDEDIR/share/man:$MANPATH
    fi
  else
    if [ "`echo $MANPATH | grep \"$KDEDIR/share/man\"`" = "" ]; then
      export MANPATH=$KDEDIR/share/man:$MANPATH
    fi
  fi
fi

if [ "$XDG_CONFIG_DIRS" = "" ]; then
  if [ -d /etc/xdg ]; then
    XDG_CONFIG_DIRS=/etc/xdg
  fi
fi
if [ -d /etc/trinity/xdg ]; then
  TDE_XDG_DIR="/etc/trinity/xdg"
elif [ -d /etc/tde/xdg ]; then
  TDE_XDG_DIR="/etc/tde/xdg"
elif [ -d $KDEDIR/xdg ]; then
  TDE_XDG_DIR="$KDEDIR/xdg"
elif [ -d $KDEDIR/etc/xdg ]; then
  TDE_XDG_DIR="$KDEDIR/etc/xdg"
elif [ -d $KDEDIR/etc/trinity/xdg ]; then
  TDE_XDG_DIR="$KDEDIR/etc/trinity/xdg"
elif [ -d $KDEDIR/etc/tde/xdg ]; then
  TDE_XDG_DIR="$KDEDIR/etc/tde/xdg"
elif [ -d $KDEDIR/trinity/xdg ]; then
  TDE_XDG_DIR="$KDEDIR/trinity/xdg"
elif [ -d $KDEDIR/tde/xdg ]; then
  TDE_XDG_DIR="$KDEDIR/tde/xdg"
fi
if [ -d $TDE_XDG_DIR ]; then
  if [ "`echo $XDG_CONFIG_DIRS | grep \"$TDE_XDG_DIR\"`" = "" ]; then
    if [ "$XDG_CONFIG_DIRS" = "" ]; then
      XDG_CONFIG_DIRS=$TDE_XDG_DIR
    else
      XDG_CONFIG_DIRS=$TDE_XDG_DIR:$XDG_CONFIG_DIRS
    fi
  fi
fi
if [ "$XDG_CONFIG_DIRS" != "" ]; then
  export XDG_CONFIG_DIRS
fi

# Explicitly set $XDG_DATA_DIRS only when Trinity is not installed in /usr.
# Explicitly declaring $XDG_DATA_DIRS will override the default search path of /usr/share.
# Explicitly declaring $XDG_DATA_DIRS will override $KDEDIRS, which must then be
# explicitly identified in the $XDG_DATA_DIRS string to remain useful.
# The $KDEDIR variable is intended to be singular and $KDEDIRS plural. When $KDEDIRS
# exists in the environment then parse that variable into separate directories.
# $KDEDIRS should contain whatever is set in $KDEDIR. Therefore any additional directories
# set in $KDEDIRS are intended to override data files found in $KDEDIR. Those additional
# directories should be placed before $KDEDIR and before /usr/share.
if [ "$KDEDIR" != "/usr" ] && [ -d $KDEDIR/share ]; then
  # If '/usr/share' is not already here, we include it at the last position.
  if ! is_in_path XDG_DATA_DIRS "/usr/share"; then
    XDG_DATA_DIRS=$XDG_DATA_DIRS:/usr/share
  fi

  # Ensure that $KDEDIR/share is always before '/usr/share'.
  remove_from_path XDG_DATA_DIRS $KDEDIR/share
  place_before_in_path XDG_DATA_DIRS "$KDEDIR/share" "/usr/share"

  # Adds supplementary directories from KDEDIRS, if any, before KDEDIR.
  if [ "$KDEDIRS" != "" ]; then
    ifs="$IFS"; IFS=":"; set $KDEDIRS; IFS="$ifs"
    for dir in $*; do
      if ! is_in_path XDG_DATA_DIRS "$dir/share" && [ -d "$dir/share" ]; then
        XDG_DATA_DIRS=$dir/share:$XDG_DATA_DIRS
      fi
    done
  fi
  export XDG_DATA_DIRS
fi

echo "[startkde] XDG_DATA_DIRS: $XDG_DATA_DIRS" 1>&2

test -n "$KDEHOME" && kdehome=`echo "$KDEHOME" | sed "s,^~/,$HOME/,"`

# 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=trinity

# Please see kstartupconfig source for usage.
if [ ! -d "$HOME/.trinity" ]; then
  echo "[startkde] Creating $HOME/.trinity." 1>&2
fi
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
$KDEDIR/bin/kstartupconfig
if test $? -ne 0; then
  xmessage -center -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 TDE libraries here, before
# TDE 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=${KDEDIRS%%:*}
  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 ~/.trinity, and <prefixes> is where TDE is installed)
#
# This is where you can define environment variables that will be available to
# all TDE 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 TDE font directories.
#
# There are 4 directories that may be used for supplying fonts for TDE.
#
# 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

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

if test -n "$KDEDIRS"; then
  kdedirs_first=${KDEDIRS%%:*}
  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=${KDEDIRS%%:*}
  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 [ "$KGTK_PRELOAD" != "" ]; then
  if [ -e /usr/lib64/libnspr4.so ]; then
    KGTK_NSPR_PRELOAD="/usr/lib64/libnspr4.so:"
  elif [ -e /usr/lib/libnspr4.so ]; then
    KGTK_NSPR_PRELOAD="/usr/lib/libnspr4.so:"
  fi
  export LD_PRELOAD=$KGTK_PRELOAD:$KGTK_NSPR_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 TDE 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 TDE 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 is linked from $KDEHOME/tmp-$HOSTNAME to it.
# - a directory $TMP/ksocket-$USER and is linked from $KDEHOME/socket-$HOSTNAME to it.
# - a directory /var/tmp/kdecache-$USER and is linked from $KDEHOME/cache-$HOSTNAME to it.
# Note: temporary locations can be overridden 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 -center -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.
$KDEDIR/bin/dcopserver_shutdown

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

# Detect any running Xorg composition managers
$KDEDIR/bin/kdetcompmgr

# 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 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
    $KDEDIR/bin/dcopserver
    $KDEDIR/bin/kwin --lock &
    $KDEDIR/bin/kpersonalizer --before-session
    # handle kpersonalizer restarts (language change)
    while test $? -eq 1; do
      $KDEDIR/bin/kpersonalizer --r --before-session
    done
    $KDEDIR/bin/dcopquit kwin
    $KDEDIR/bin/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
        $KDEDIR/bin/ksplashsimple
      fi # otherwise started earlier
      ;;
    *)
      $KDEDIR/bin/ksplash --nodcop
      ;;
  esac
fi

# Mark that full TDE session is running (e.g. Konqueror preloading works only
# with full TDE running). The TDE_FULL_SESSION property can be detected by
# any X client connected to the same X session, even if not launched
# directly from the TDE session but e.g. using "ssh -X", kdesu. $TDE_FULL_SESSION
# however guarantees that the application is launched in the same environment
# like the TDE session and that e.g. TDE utilities/libraries are available.
# The matching tests are:
#   For $TDE_FULL_SESSION:
#     if test -n "$TDE_FULL_SESSION"; then ... whatever
#   For TDE_FULL_SESSION property:
#     xprop -root | grep "^TDE_FULL_SESSION" >/dev/null 2>/dev/null
#     if test $? -eq 0; then ... whatever
#
# Additionally there is $KDE_SESSION_UID with the uid of the user
# running the TDE session. It should be rarely needed (for example,
# after sudo to prevent desktop-wide functionality in the new user's kded).
#
TDE_FULL_SESSION=true
export TDE_FULL_SESSION
xprop -root -f TDE_FULL_SESSION 8t -set TDE_FULL_SESSION true
echo "[startkde] TDE_FULL_SESSION: $TDE_FULL_SESSION" 1>&2
KDE_SESSION_UID=`id -u`
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 $KDEDIR/bin/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 -center -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 TDE startup underneath the locker.
# FIXME
# kdesktop needs to be notified of this locker process somehow so that
# it does not attempt to launch its own locker process on startup!
if test -n "$dl"; then
  $KDEDIR/bin/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"
$KDEDIR/bin/kwrapper ksmserver $KDEWM
if test $? -eq 255; then
  # Startup error
  echo '[startkde] Could not start ksmserver. Check your installation.' 1>&2
  xmessage -center -geometry 500x100 "Could not start ksmserver. Check your installation."
fi

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

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

# Clean up
$KDEDIR/bin/kdeinit_shutdown
$KDEDIR/bin/dcopserver_shutdown --wait
$KDEDIR/bin/artsshell -q terminate
# KDE4 support
if [ -f /usr/bin/kdeinit4_shutdown ]; then
  /usr/bin/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 TDE_FULL_SESSION
xprop -root -remove TDE_FULL_SESSION
unset KDE_SESSION_UID

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