diff --git a/Admin/components/components.sha1 b/Admin/components/components.sha1
--- a/Admin/components/components.sha1
+++ b/Admin/components/components.sha1
@@ -1,53 +1,54 @@
 2f6417b8e96a0e4e8354fe0f1a253c18fb55d9a7  cvc3-2.4.1.tar.gz
 842d9526f37b928cf9e22f141884365129990d63  cygwin-20130110.tar.gz
 cb3b0706d208f104b800267697204f6d82f7b48a  cygwin-20130114.tar.gz
 3b44cca04855016d5f8cfb5101b2e0579ab80197  cygwin-20130117.tar.gz
 0fe549949a025d65d52d6deca30554de8fca3b6e  e-1.5.tar.gz
 2e293256a134eb8e5b1a283361b15eb812fbfbf1  e-1.6-1.tar.gz
 e1919e72416cbd7ac8de5455caba8901acc7b44d  e-1.6-2.tar.gz
 b98a98025d1f7e560ca6864a53296137dae736b4  e-1.6.tar.gz
 6d34b18ca0aa1e10bab6413045d079188c0e2dfb  exec_process-1.0.1.tar.gz
 8b9bffd10e396d965e815418295f2ee2849bea75  exec_process-1.0.2.tar.gz
 e6aada354da11e533af2dee3dcdd96c06479b053  exec_process-1.0.3.tar.gz
 ae7ee5becb26512f18c609e83b34612918bae5f0  exec_process-1.0.tar.gz
 59a71e08c34ff01f3f5c4af00db5e16369527eb7  Haskabelle-2013.tar.gz
 683acd94761ef460cca1a628f650355370de5afb  hol-light-bundle-0.5-126.tar.gz
 8d83e433c1419e0c0cc5fd1762903d11b4a5752c  jdk-6u31.tar.gz
 38d2d2a91c66714c18430e136e7e5191af3996e6  jdk-7u11.tar.gz
 d765bc4ad2f34d494429b2a8c1563c49db224944  jdk-7u13.tar.gz
 13a265e4b706ece26fdfa6fc9f4a3dd1366016d2  jdk-7u21.tar.gz
 ec740ee9ffd43551ddf1e5b91641405116af6291  jdk-7u6.tar.gz
 7d5b152ac70f720bb9e783fa45ecadcf95069584  jdk-7u9.tar.gz
 44775a22f42a9d665696bfb49e53c79371c394b0  jedit_build-20111217.tar.gz
 a242a688810f2bccf24587b0062ce8027bf77fa2  jedit_build-20120304.tar.gz
 4c948dee53f74361c097c08f49a1a5ff9b17bd1d  jedit_build-20120307.tar.gz
 9c221fe71af8a063fcffcce21672a97aea0a8d5b  jedit_build-20120313.tar.gz
 ed72630f307729df08fdedb095f0af8725f81b9c  jedit_build-20120327.tar.gz
 6425f622625024c1de27f3730d6811f6370a19cd  jedit_build-20120414.tar.gz
 7b012f725ec1cc102dc259df178d511cc7890bba  jedit_build-20120813.tar.gz
 8e1d36f5071e3def2cb281f7fefe9f52352cb88f  jedit_build-20120903.tar.gz
 8fa0c67f59beba369ab836562eed4e56382f672a  jedit_build-20121201.tar.gz
 06e9be2627ebb95c45a9bcfa025d2eeef086b408  jedit_build-20130104.tar.gz
+c85c0829b8170f25aa65ec6852f505ce2a50639b  jedit_build-20130628.tar.gz
 8122526f1fc362ddae1a328bdbc2152853186fee  jfreechart-1.0.14.tar.gz
 6c737137cc597fc920943783382e928ea79e3feb  kodkodi-1.2.16.tar.gz
 5f95c96bb99927f3a026050f85bd056f37a9189e  kodkodi-1.5.2.tar.gz
 1c8cb6a8f4cbeaedce2d6d1ba8fc7e2ab3663aeb  polyml-5.4.1.tar.gz
 a3f9c159a0ee9a63b7a5d0c835ed9c2c908f8b56  polyml-5.5.0-1.tar.gz
 7d604a99355efbfc1459d80db3279ffa7ade3e39  polyml-5.5.0-2.tar.gz
 b3d776e6744f0cd2773d467bc2cfe1de3d1ca2fd  polyml-5.5.0-3.tar.gz
 1812e9fa6d163f63edb93e37d1217640a166cf3e  polyml-5.5.0.tar.gz
 8ee375cfc38972f080dbc78f07b68dac03efe968  ProofGeneral-3.7.1.1.tar.gz
 847b52c0676b5eb0fbf0476f64fc08c2d72afd0c  ProofGeneral-4.1.tar.gz
 8472221c876a430cde325841ce52893328302712  ProofGeneral-4.2.tar.gz
 0885e1f1d8feaca78d2f204b6487e6eec6dfab4b  scala-2.10.0.tar.gz
 f7dc7a4e1aea46408fd6e44b8cfacb33af61afbc  scala-2.10.1.tar.gz
 207e4916336335386589c918c5e3f3dcc14698f2  scala-2.10.2.tar.gz
 b447017e81600cc5e30dd61b5d4962f6da01aa80  scala-2.8.1.final.tar.gz
 5659440f6b86db29f0c9c0de7249b7e24a647126  scala-2.9.2.tar.gz
 43b5afbcad575ab6817d2289756ca22fd2ef43a9  spass-3.8ds.tar.gz
 1f4a2053cc1f34fa36c4d9d2ac906ad4ebc863fd  sumatra_pdf-2.1.1.tar.gz
 869ea6d8ea35c8ba68d7fcb028f16b2b7064c5fd  vampire-1.0.tar.gz
 2ae13aa17d0dc95ce254a52f1dba10929763a10d  xz-java-1.2.tar.gz
 4530a1aa6f4498ee3d78d6000fa71a3f63bd077f  yices-1.0.28.tar.gz
 12ae71acde43bd7bed1e005c43034b208c0cba4c  z3-3.2.tar.gz
 d94a716502c8503d63952bcb4d4176fac8b28704  z3-4.0.tar.gz
diff --git a/Admin/components/main b/Admin/components/main
--- a/Admin/components/main
+++ b/Admin/components/main
@@ -1,14 +1,14 @@
 #main components for everyday use, without big impact on overall build time
 cvc3-2.4.1
 e-1.6-2
 exec_process-1.0.3
 Haskabelle-2013
 jdk-7u21
-jedit_build-20130104
+jedit_build-20130628
 jfreechart-1.0.14
 kodkodi-1.5.2
 polyml-5.5.0-3
 scala-2.10.2
 spass-3.8ds
 z3-3.2
 xz-java-1.2
diff --git a/src/Tools/jEdit/lib/Tools/jedit b/src/Tools/jEdit/lib/Tools/jedit
--- a/src/Tools/jEdit/lib/Tools/jedit
+++ b/src/Tools/jEdit/lib/Tools/jedit
@@ -1,341 +1,342 @@
 #!/usr/bin/env bash
 #
 # Author: Makarius
 #
 # DESCRIPTION: Isabelle/jEdit interface wrapper
 
 
 ## sources
 
 declare -a SOURCES=(
   "src/active.scala"
   "src/dockable.scala"
   "src/document_model.scala"
   "src/document_view.scala"
   "src/documentation_dockable.scala"
   "src/fold_handling.scala"
   "src/graphview_dockable.scala"
   "src/html_panel.scala"
   "src/hyperlink.scala"
   "src/info_dockable.scala"
   "src/isabelle.scala"
   "src/isabelle_encoding.scala"
   "src/isabelle_logic.scala"
   "src/isabelle_options.scala"
   "src/isabelle_sidekick.scala"
   "src/jedit_lib.scala"
   "src/jedit_main.scala"
   "src/jedit_options.scala"
   "src/jedit_thy_load.scala"
   "src/monitor_dockable.scala"
   "src/osx_adapter.scala"
   "src/output_dockable.scala"
   "src/plugin.scala"
   "src/pretty_text_area.scala"
   "src/pretty_tooltip.scala"
   "src/protocol_dockable.scala"
   "src/raw_output_dockable.scala"
   "src/readme_dockable.scala"
   "src/rendering.scala"
   "src/rich_text_area.scala"
   "src/scala_console.scala"
   "src/symbols_dockable.scala"
   "src/syslog_dockable.scala"
   "src/text_overview.scala"
   "src/theories_dockable.scala"
   "src/timing_dockable.scala"
   "src/token_markup.scala"
 )
 
 declare -a RESOURCES=(
   "src/actions.xml"
   "src/dockables.xml"
   "src/Isabelle.props"
   "src/jEdit.props"
   "src/services.xml"
 )
 
 
 ## diagnostics
 
 PRG="$(basename "$0")"
 
 function usage()
 {
   echo
   echo "Usage: isabelle $PRG [OPTIONS] [FILES ...]"
   echo
   echo "  Options are:"
   echo "    -J OPTION    add JVM runtime option"
   echo "                 (default JEDIT_JAVA_OPTIONS=$JEDIT_JAVA_OPTIONS)"
   echo "    -b           build only"
   echo "    -d DIR       include session directory"
   echo "    -f           fresh build"
   echo "    -j OPTION    add jEdit runtime option"
   echo "                 (default JEDIT_OPTIONS=$JEDIT_OPTIONS)"
   echo "    -l NAME      logic session name"
   echo "    -m MODE      add print mode for output"
   echo "    -n           no build dialog for session image on startup"
   echo "    -s           system build mode for session image"
   echo
   echo "Start jEdit with Isabelle plugin setup and open theory FILES"
   echo "(default \"$USER_HOME/Scratch.thy\")."
   echo
   exit 1
 }
 
 function fail()
 {
   echo "$1" >&2
   exit 2
 }
 
 function failed()
 {
   fail "Failed!"
 }
 
 
 ## process command line
 
 # options
 
 declare -a BUILD_DIALOG_OPTIONS=(-L jedit_logic)
 
 BUILD_ONLY=false
 BUILD_JARS="jars"
 JEDIT_SESSION_DIRS=""
 JEDIT_LOGIC=""
 JEDIT_PRINT_MODE=""
 NO_BUILD="false"
 
 function getoptions()
 {
   OPTIND=1
   while getopts "J:bd:fj:l:m:ns" OPT
   do
     case "$OPT" in
       J)
         JAVA_ARGS["${#JAVA_ARGS[@]}"]="$OPTARG"
         ;;
       b)
         BUILD_ONLY=true
         ;;
       d)
         if [ -z "$JEDIT_SESSION_DIRS" ]; then
           JEDIT_SESSION_DIRS="$OPTARG"
         else
           JEDIT_SESSION_DIRS="$JEDIT_SESSION_DIRS:$OPTARG"
         fi
         BUILD_DIALOG_OPTIONS["${#BUILD_DIALOG_OPTIONS[@]}"]="-d"
         BUILD_DIALOG_OPTIONS["${#BUILD_DIALOG_OPTIONS[@]}"]="$OPTARG"
         ;;
       f)
         BUILD_JARS="jars_fresh"
         ;;
       j)
         ARGS["${#ARGS[@]}"]="$OPTARG"
         ;;
       l)
         BUILD_DIALOG_OPTIONS["${#BUILD_DIALOG_OPTIONS[@]}"]="-l"
         BUILD_DIALOG_OPTIONS["${#BUILD_DIALOG_OPTIONS[@]}"]="$OPTARG"
         JEDIT_LOGIC="$OPTARG"
         ;;
       m)
         if [ -z "$JEDIT_PRINT_MODE" ]; then
           JEDIT_PRINT_MODE="$OPTARG"
         else
           JEDIT_PRINT_MODE="$JEDIT_PRINT_MODE,$OPTARG"
         fi
         ;;
       n)
         NO_BUILD="true"
         ;;
       s)
         BUILD_DIALOG_OPTIONS["${#BUILD_DIALOG_OPTIONS[@]}"]="-s"
         ;;
       \?)
         usage
         ;;
     esac
   done
 }
 
 declare -a JAVA_ARGS; eval "JAVA_ARGS=($JEDIT_JAVA_OPTIONS $JEDIT_SYSTEM_OPTIONS)"
 [ -n "$SCALA_HOME" ] && JAVA_ARGS["${#JAVA_ARGS[@]}"]="-Dscala.home=$SCALA_HOME"
 
 declare -a ARGS; eval "ARGS=($JEDIT_OPTIONS)"
 
 declare -a OPTIONS; eval "OPTIONS=($ISABELLE_JEDIT_OPTIONS)"
 getoptions "${OPTIONS[@]}"
 
 getoptions "$@"
 shift $(($OPTIND - 1))
 
 
 # args
 
 if [ "$#" -eq 0 ]; then
   ARGS["${#ARGS[@]}"]="$(jvmpath "$USER_HOME/Scratch.thy")"
 else
   while [ "$#" -gt 0 ]; do
     ARGS["${#ARGS[@]}"]="$(jvmpath "$1")"
     shift
   done
 fi
 
 
 ## dependencies
 
 if [ -e "$ISABELLE_HOME/Admin/build" ]; then
   "$ISABELLE_TOOL" browser -b || exit $?
   if [ "$BUILD_JARS" = jars_fresh ]; then
     "$ISABELLE_TOOL" graphview -b -f || exit $?
   else
     "$ISABELLE_HOME/Admin/build" "$BUILD_JARS" || exit $?
     "$ISABELLE_TOOL" graphview -b || exit $?
   fi
 fi
 
 PURE_JAR="$ISABELLE_HOME/lib/classes/ext/Pure.jar"
 GRAPHVIEW_JAR="$ISABELLE_HOME/lib/classes/ext/Graphview.jar"
 
 pushd "$JEDIT_HOME" >/dev/null || failed
 
 JEDIT_JAR="$ISABELLE_JEDIT_BUILD_HOME/contrib/$ISABELLE_JEDIT_BUILD_VERSION/jedit.jar"
 
 JEDIT_JARS=(
   "$ISABELLE_JEDIT_BUILD_HOME/contrib/Console.jar"
   "$ISABELLE_JEDIT_BUILD_HOME/contrib/ErrorList.jar"
   "$ISABELLE_JEDIT_BUILD_HOME/contrib/Highlight.jar"
   "$ISABELLE_JEDIT_BUILD_HOME/contrib/SideKick.jar"
   "$ISABELLE_JEDIT_BUILD_HOME/contrib/cobra.jar"
   "$ISABELLE_JEDIT_BUILD_HOME/contrib/js.jar"
+  "$ISABELLE_JEDIT_BUILD_HOME/contrib/idea-icons.jar"
 )
 
 declare -a JFREECHART_JARS=()
 for NAME in $JFREECHART_JAR_NAMES
 do
   JFREECHART_JARS["${#JFREECHART_JARS[@]}"]="$JFREECHART_HOME/lib/$NAME"
 done
 
 
 # target
 
 TARGET="dist/jars/Isabelle-jEdit.jar"
 
 declare -a UPDATED=()
 
 if [ "$BUILD_JARS" = jars_fresh ]; then
   OUTDATED=true
 else
   OUTDATED=false
   if [ ! -e "$TARGET" ]; then
     OUTDATED=true
   else
     if [ -n "$ISABELLE_JEDIT_BUILD_HOME" ]; then
       declare -a DEPS=(
         "$JEDIT_JAR" "${JEDIT_JARS[@]}" "${JFREECHART_JARS[@]}" "$XZ_JAVA_HOME/lib/xz.jar"
         "$PURE_JAR" "$GRAPHVIEW_JAR" "${SOURCES[@]}" "${RESOURCES[@]}"
       )
     elif [ -e "$ISABELLE_HOME/Admin/build" ]; then
       declare -a DEPS=("$PURE_JAR" "$GRAPHVIEW_JAR" "${SOURCES[@]}" "${RESOURCES[@]}")
     else
       declare -a DEPS=()
     fi
     for DEP in "${DEPS[@]}"
     do
       [ ! -e "$DEP" ] && fail "Missing file: $DEP"
       [ "$DEP" -nt "$TARGET" ] && {
         OUTDATED=true
         UPDATED["${#UPDATED[@]}"]="$DEP"
       }
     done
   fi
 fi
 
 
 # build
 
 if [ "$OUTDATED" = true ]
 then
   echo "### Building Isabelle/jEdit ..."
 
   [ "${#UPDATED[@]}" -gt 0 ] && {
     echo "Changed files:"
     for FILE in "${UPDATED[@]}"
     do
       echo "  $FILE"
     done
   }
 
   [ -z "$ISABELLE_JEDIT_BUILD_HOME" ] && \
     fail "Unknown ISABELLE_JEDIT_BUILD_HOME -- missing auxiliary component"
 
   rm -rf dist || failed
   mkdir -p dist dist/classes || failed
 
   cp -p -R -f "$ISABELLE_JEDIT_BUILD_HOME/contrib/$ISABELLE_JEDIT_BUILD_VERSION/." dist/.
   cp -p -R -f "${RESOURCES[@]}" dist/classes/.
   cp src/jEdit.props dist/properties/.
   cp -p -R -f src/modes/. dist/modes/.
 
   perl -i -e 'while (<>) {
     if (m/NAME="javacc"/) {
       print qq,<MODE NAME="isabelle" FILE="isabelle.xml" FILE_NAME_GLOB="*.thy"/>\n\n,;
       print qq,<MODE NAME="isabelle-options" FILE="isabelle-options.xml"/>\n\n,;
       print qq,<MODE NAME="isabelle-root" FILE="isabelle-root.xml" FILE_NAME_GLOB="ROOT"/>\n\n,; }
     print; }' dist/modes/catalog
 
   cp -p -R -f "${JEDIT_JARS[@]}" dist/jars/. || failed
   (
     for JAR in "$JEDIT_JAR" "${JEDIT_JARS[@]}" "${JFREECHART_JARS[@]}" "$XZ_JAVA_HOME/lib/xz.jar" \
       "$PURE_JAR" "$GRAPHVIEW_JAR" "$SCALA_HOME/lib/scala-compiler.jar"
     do
       CLASSPATH="$CLASSPATH:$JAR"
     done
     CLASSPATH="$(jvmpath "$CLASSPATH")"
     exec "$SCALA_HOME/bin/scalac" $ISABELLE_SCALA_BUILD_OPTIONS -d dist/classes "${SOURCES[@]}"
   ) || fail "Failed to compile sources"
 
   cd dist/classes
   isabelle_jdk jar cf "../jars/Isabelle-jEdit.jar" * || failed
   cd ../..
   rm -rf dist/classes
 fi
 
 popd >/dev/null
 
 
 ## main
 
 if [ "$BUILD_ONLY" = false ]; then
   mkdir -p "$JEDIT_SETTINGS/DockableWindowManager"
 
   if [ ! -e "$JEDIT_SETTINGS/perspective.xml" ]; then
     cat > "$JEDIT_SETTINGS/DockableWindowManager/perspective-view0.xml" <<EOF
 <DOCKING LEFT="" TOP="" RIGHT="" BOTTOM="isabelle-readme" LEFT_POS="0" TOP_POS="0" RIGHT_POS="250" BOTTOM_POS="250" />
 EOF
   cat > "$JEDIT_SETTINGS/perspective.xml" <<EOF
 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE PERSPECTIVE SYSTEM "perspective.dtd">
 <PERSPECTIVE>
 <VIEW PLAIN="FALSE">
 <GEOMETRY X="0" Y="35" WIDTH="1072" HEIGHT="787" EXT_STATE="0" />
 </VIEW>
 </PERSPECTIVE>
 EOF
   fi
 
   if [ "$NO_BUILD" = false ]; then
     "$ISABELLE_TOOL" build_dialog "${BUILD_DIALOG_OPTIONS[@]}"
     RC="$?"
     [ "$RC" = 0 ] || exit "$RC"
   fi
 
   export JEDIT_SESSION_DIRS JEDIT_LOGIC JEDIT_PRINT_MODE
 
   exec "$ISABELLE_TOOL" java "${JAVA_ARGS[@]}" \
     -jar "$(jvmpath "$JEDIT_HOME/dist/jedit.jar")" \
     "-settings=$(jvmpath "$JEDIT_SETTINGS")" "${ARGS[@]}"
 fi
diff --git a/src/Tools/jEdit/src/rendering.scala b/src/Tools/jEdit/src/rendering.scala
--- a/src/Tools/jEdit/src/rendering.scala
+++ b/src/Tools/jEdit/src/rendering.scala
@@ -1,582 +1,589 @@
 /*  Title:      Tools/jEdit/src/rendering.scala
     Author:     Makarius
 
 Isabelle-specific implementation of quasi-abstract rendering and
 markup interpretation.
 */
 
 package isabelle.jedit
 
 
 import isabelle._
 
 import java.awt.Color
 import javax.swing.Icon
 
 import org.gjt.sp.jedit.syntax.{Token => JEditToken}
 import org.gjt.sp.jedit.{jEdit, GUIUtilities}
 
 import scala.collection.immutable.SortedMap
 
 
 object Rendering
 {
   def apply(snapshot: Document.Snapshot, options: Options): Rendering =
     new Rendering(snapshot, options)
 
 
   /* message priorities */
 
   private val writeln_pri = 1
   private val tracing_pri = 2
   private val warning_pri = 3
   private val legacy_pri = 4
   private val error_pri = 5
 
   private val message_pri = Map(
     Markup.WRITELN -> writeln_pri, Markup.WRITELN_MESSAGE -> writeln_pri,
     Markup.TRACING -> tracing_pri, Markup.TRACING_MESSAGE -> tracing_pri,
     Markup.WARNING -> warning_pri, Markup.WARNING_MESSAGE -> warning_pri,
     Markup.ERROR -> error_pri, Markup.ERROR_MESSAGE -> error_pri)
 
 
   /* icons */
 
-  private def load_icon(name: String): Icon =
+  def load_icon(name: String): Icon =
   {
-    val icon = GUIUtilities.loadIcon(name)
+    val name1 =
+      if (name.startsWith("idea-icons/")) {
+        val file =
+          Isabelle_System.platform_file_url(Path.explode("$JEDIT_HOME/dist/jars/idea-icons.jar"))
+        "jar:" + file + "!/" + name
+      }
+      else name
+    val icon = GUIUtilities.loadIcon(name1)
     if (icon.getIconWidth < 0 || icon.getIconHeight < 0) error("Bad icon: " + name)
     else icon
   }
 
   private val gutter_icons = Map(
     warning_pri -> load_icon("16x16/status/dialog-information.png"),
     legacy_pri -> load_icon("16x16/status/dialog-warning.png"),
     error_pri -> load_icon("16x16/status/dialog-error.png"))
 
   val tooltip_close_icon = load_icon("16x16/actions/document-close.png")
   val tooltip_detach_icon = load_icon("16x16/actions/window-new.png")
 
 
   /* jEdit font */
 
   def font_family(): String = jEdit.getProperty("view.font")
 
   def font_size(scale: String): Float =
     (jEdit.getIntegerProperty("view.fontsize", 16) * PIDE.options.real(scale)).toFloat
 
 
   /* token markup -- text styles */
 
   private val command_style: Map[String, Byte] =
   {
     import JEditToken._
     Map[String, Byte](
       Keyword.THY_END -> KEYWORD2,
       Keyword.THY_SCRIPT -> LABEL,
       Keyword.PRF_SCRIPT -> DIGIT,
       Keyword.PRF_ASM -> KEYWORD3,
       Keyword.PRF_ASM_GOAL -> KEYWORD3
     ).withDefaultValue(KEYWORD1)
   }
 
   private val token_style: Map[Token.Kind.Value, Byte] =
   {
     import JEditToken._
     Map[Token.Kind.Value, Byte](
       Token.Kind.KEYWORD -> KEYWORD2,
       Token.Kind.IDENT -> NULL,
       Token.Kind.LONG_IDENT -> NULL,
       Token.Kind.SYM_IDENT -> NULL,
       Token.Kind.VAR -> NULL,
       Token.Kind.TYPE_IDENT -> NULL,
       Token.Kind.TYPE_VAR -> NULL,
       Token.Kind.NAT -> NULL,
       Token.Kind.FLOAT -> NULL,
       Token.Kind.STRING -> LITERAL1,
       Token.Kind.ALT_STRING -> LITERAL2,
       Token.Kind.VERBATIM -> COMMENT3,
       Token.Kind.SPACE -> NULL,
       Token.Kind.COMMENT -> COMMENT1,
       Token.Kind.ERROR -> INVALID
     ).withDefaultValue(NULL)
   }
 
   def token_markup(syntax: Outer_Syntax, token: Token): Byte =
     if (token.is_command) command_style(syntax.keyword_kind(token.content).getOrElse(""))
     else if (token.is_operator) JEditToken.OPERATOR
     else token_style(token.kind)
 }
 
 
 class Rendering private(val snapshot: Document.Snapshot, val options: Options)
 {
   /* colors */
 
   def color_value(s: String): Color = Color_Value(options.string(s))
 
   val outdated_color = color_value("outdated_color")
   val unprocessed_color = color_value("unprocessed_color")
   val unprocessed1_color = color_value("unprocessed1_color")
   val running_color = color_value("running_color")
   val running1_color = color_value("running1_color")
   val light_color = color_value("light_color")
   val bullet_color = color_value("bullet_color")
   val tooltip_color = color_value("tooltip_color")
   val writeln_color = color_value("writeln_color")
   val warning_color = color_value("warning_color")
   val error_color = color_value("error_color")
   val error1_color = color_value("error1_color")
   val writeln_message_color = color_value("writeln_message_color")
   val tracing_message_color = color_value("tracing_message_color")
   val warning_message_color = color_value("warning_message_color")
   val error_message_color = color_value("error_message_color")
   val bad_color = color_value("bad_color")
   val intensify_color = color_value("intensify_color")
   val quoted_color = color_value("quoted_color")
   val antiquoted_color = color_value("antiquoted_color")
   val highlight_color = color_value("highlight_color")
   val hyperlink_color = color_value("hyperlink_color")
   val active_color = color_value("active_color")
   val active_hover_color = color_value("active_hover_color")
   val active_result_color = color_value("active_result_color")
   val keyword1_color = color_value("keyword1_color")
   val keyword2_color = color_value("keyword2_color")
 
   val tfree_color = color_value("tfree_color")
   val tvar_color = color_value("tvar_color")
   val free_color = color_value("free_color")
   val skolem_color = color_value("skolem_color")
   val bound_color = color_value("bound_color")
   val var_color = color_value("var_color")
   val inner_numeral_color = color_value("inner_numeral_color")
   val inner_quoted_color = color_value("inner_quoted_color")
   val inner_comment_color = color_value("inner_comment_color")
   val dynamic_color = color_value("dynamic_color")
 
 
   /* command overview */
 
   val overview_limit = options.int("jedit_text_overview_limit")
 
   private val overview_include = Protocol.command_status_markup + Markup.WARNING + Markup.ERROR
 
   def overview_color(range: Text.Range): Option[Color] =
   {
     if (snapshot.is_outdated) None
     else {
       val results =
         snapshot.cumulate_markup[(Protocol.Status, Int)](
           range, (Protocol.Status.init, 0), Some(overview_include), _ =>
           {
             case ((status, pri), Text.Info(_, XML.Elem(markup, _)))
             if overview_include(markup.name) =>
               if (markup.name == Markup.WARNING || markup.name == Markup.ERROR)
                 (status, pri max Rendering.message_pri(markup.name))
               else (Protocol.command_status(status, markup), pri)
           })
       if (results.isEmpty) None
       else {
         val (status, pri) =
           ((Protocol.Status.init, 0) /: results) {
             case ((s1, p1), Text.Info(_, (s2, p2))) => (s1 + s2, p1 max p2) }
 
         if (status.is_running) Some(running_color)
         else if (pri == Rendering.warning_pri) Some(warning_color)
         else if (pri == Rendering.error_pri) Some(error_color)
         else if (status.is_unprocessed) Some(unprocessed_color)
         else if (status.is_failed) Some(error_color)
         else None
       }
     }
   }
 
 
   /* markup selectors */
 
   private val highlight_include =
     Set(Markup.SORT, Markup.TYP, Markup.TERM, Markup.PROP, Markup.ML_TYPING, Markup.TOKEN_RANGE,
       Markup.ENTITY, Markup.PATH, Markup.SORTING, Markup.TYPING, Markup.FREE, Markup.SKOLEM,
       Markup.BOUND, Markup.VAR, Markup.TFREE, Markup.TVAR, Markup.ML_SOURCE, Markup.DOCUMENT_SOURCE)
 
   def highlight(range: Text.Range): Option[Text.Info[Color]] =
   {
     snapshot.select_markup(range, Some(highlight_include), _ =>
         {
           case Text.Info(info_range, XML.Elem(Markup(name, _), _)) if highlight_include(name) =>
             Text.Info(snapshot.convert(info_range), highlight_color)
         }) match { case Text.Info(_, info) #:: _ => Some(info) case _ => None }
   }
 
 
   private val hyperlink_include = Set(Markup.ENTITY, Markup.PATH)
 
   def hyperlink(range: Text.Range): Option[Text.Info[Hyperlink]] =
   {
     snapshot.cumulate_markup[List[Text.Info[Hyperlink]]](range, Nil, Some(hyperlink_include), _ =>
         {
           case (links, Text.Info(info_range, XML.Elem(Markup.Path(name), _)))
           if Path.is_ok(name) =>
             val jedit_file = PIDE.thy_load.append(snapshot.node_name.dir, Path.explode(name))
             Text.Info(snapshot.convert(info_range), Hyperlink(jedit_file, 0, 0)) :: links
 
           case (links, Text.Info(info_range, XML.Elem(Markup(Markup.ENTITY, props), _)))
           if !props.exists(
             { case (Markup.KIND, Markup.ML_OPEN) => true
               case (Markup.KIND, Markup.ML_STRUCT) => true
               case _ => false }) =>
 
             props match {
               case Position.Def_Line_File(line, name) if Path.is_ok(name) =>
                 Isabelle_System.source_file(Path.explode(name)) match {
                   case Some(path) =>
                     val jedit_file = Isabelle_System.platform_path(path)
                     Text.Info(snapshot.convert(info_range), Hyperlink(jedit_file, line, 0)) :: links
                   case None => links
                 }
 
               case Position.Def_Id_Offset(id, offset) =>
                 snapshot.state.find_command(snapshot.version, id) match {
                   case Some((node, command)) =>
                     val sources =
                       node.commands.iterator.takeWhile(_ != command).map(_.source) ++
                         Iterator.single(command.source(Text.Range(0, command.decode(offset))))
                     val (line, column) = ((1, 1) /: sources)(Symbol.advance_line_column)
                     Text.Info(snapshot.convert(info_range),
                       Hyperlink(command.node_name.node, line, column)) :: links
                   case None => links
                 }
 
               case _ => links
             }
         }) match { case Text.Info(_, info :: _) #:: _ => Some(info) case _ => None }
   }
 
 
   private val active_include =
     Set(Markup.BROWSER, Markup.GRAPHVIEW, Markup.SENDBACK, Markup.DIALOG)
 
   def active(range: Text.Range): Option[Text.Info[XML.Elem]] =
     snapshot.select_markup(range, Some(active_include), command_state =>
         {
           case Text.Info(info_range, elem @ Protocol.Dialog(_, serial, _))
           if !command_state.results.defined(serial) =>
             Text.Info(snapshot.convert(info_range), elem)
           case Text.Info(info_range, elem @ XML.Elem(Markup(name, _), _))
           if name == Markup.BROWSER || name == Markup.GRAPHVIEW || name == Markup.SENDBACK =>
             Text.Info(snapshot.convert(info_range), elem)
         }) match { case Text.Info(_, info) #:: _ => Some(info) case _ => None }
 
 
   def command_results(range: Text.Range): Command.Results =
   {
     val results =
       snapshot.select_markup[Command.Results](range, None, command_state =>
         { case _ => command_state.results }).map(_.info)
     (Command.Results.empty /: results)(_ ++ _)
   }
 
   def tooltip_message(range: Text.Range): Option[Text.Info[XML.Body]] =
   {
     val results =
       snapshot.cumulate_markup[List[Text.Info[Command.Results.Entry]]](range, Nil,
         Some(Set(Markup.WRITELN, Markup.WARNING, Markup.ERROR, Markup.BAD)), _ =>
         {
           case (msgs, Text.Info(info_range,
             XML.Elem(Markup(name, props @ Markup.Serial(serial)), body)))
           if name == Markup.WRITELN || name == Markup.WARNING || name == Markup.ERROR =>
             val entry: Command.Results.Entry =
               (serial -> XML.Elem(Markup(Markup.message(name), props), body))
             Text.Info(snapshot.convert(info_range), entry) :: msgs
 
           case (msgs, Text.Info(info_range, msg @ XML.Elem(Markup(Markup.BAD, _), body)))
           if !body.isEmpty =>
             val entry: Command.Results.Entry = (Document.new_id(), msg)
             Text.Info(snapshot.convert(info_range), entry) :: msgs
         }).toList.flatMap(_.info)
     if (results.isEmpty) None
     else {
       val r = Text.Range(results.head.range.start, results.last.range.stop)
       val msgs = Command.Results.make(results.map(_.info))
       Some(Text.Info(r, Pretty.separate(msgs.entries.map(_._2).toList)))
     }
   }
 
 
   private val tooltips: Map[String, String] =
     Map(
       Markup.SORT -> "sort",
       Markup.TYP -> "type",
       Markup.TERM -> "term",
       Markup.PROP -> "proposition",
       Markup.TOKEN_RANGE -> "inner syntax token",
       Markup.FREE -> "free variable",
       Markup.SKOLEM -> "skolem variable",
       Markup.BOUND -> "bound variable",
       Markup.VAR -> "schematic variable",
       Markup.TFREE -> "free type variable",
       Markup.TVAR -> "schematic type variable",
       Markup.ML_SOURCE -> "ML source",
       Markup.DOCUMENT_SOURCE -> "document source")
 
   private val tooltip_elements =
     Set(Markup.TIMING, Markup.ENTITY, Markup.SORTING, Markup.TYPING,
       Markup.ML_TYPING, Markup.PATH) ++ tooltips.keys
 
   private def pretty_typing(kind: String, body: XML.Body): XML.Tree =
     Pretty.block(XML.Text(kind) :: Pretty.Break(1) :: body)
 
   private val timing_threshold: Double = options.real("jedit_timing_threshold")
 
   def tooltip(range: Text.Range): Option[Text.Info[XML.Body]] =
   {
     def add(prev: Text.Info[(Timing, List[(Boolean, XML.Tree)])],
       r0: Text.Range, p: (Boolean, XML.Tree)): Text.Info[(Timing, List[(Boolean, XML.Tree)])] =
     {
       val r = snapshot.convert(r0)
       val (t, info) = prev.info
       if (prev.range == r) Text.Info(r, (t, p :: info)) else Text.Info(r, (t, List(p)))
     }
 
     val results =
       snapshot.cumulate_markup[Text.Info[(Timing, List[(Boolean, XML.Tree)])]](
         range, Text.Info(range, (Timing.zero, Nil)), Some(tooltip_elements), _ =>
         {
           case (Text.Info(r, (t1, info)), Text.Info(_, XML.Elem(Markup.Timing(t2), _))) =>
             Text.Info(r, (t1 + t2, info))
           case (prev, Text.Info(r, XML.Elem(Markup.Entity(kind, name), _))) =>
             val kind1 = space_explode('_', kind).mkString(" ")
             val txt1 = kind1 + " " + quote(name)
             val t = prev.info._1
             val txt2 =
               if (kind == Markup.COMMAND && t.elapsed.seconds >= timing_threshold)
                 "\n" + t.message
               else ""
             add(prev, r, (true, XML.Text(txt1 + txt2)))
           case (prev, Text.Info(r, XML.Elem(Markup.Path(name), _)))
           if Path.is_ok(name) =>
             val jedit_file = PIDE.thy_load.append(snapshot.node_name.dir, Path.explode(name))
             add(prev, r, (true, XML.Text("file " + quote(jedit_file))))
           case (prev, Text.Info(r, XML.Elem(Markup(name, _), body)))
           if name == Markup.SORTING || name == Markup.TYPING =>
             add(prev, r, (true, pretty_typing("::", body)))
           case (prev, Text.Info(r, XML.Elem(Markup(Markup.ML_TYPING, _), body))) =>
             add(prev, r, (false, pretty_typing("ML:", body)))
           case (prev, Text.Info(r, XML.Elem(Markup(name, _), _)))
           if tooltips.isDefinedAt(name) =>
             add(prev, r, (true, XML.Text(tooltips(name))))
         }).toList.map(_.info)
 
     results.map(_.info).flatMap(_._2) match {
       case Nil => None
       case tips =>
         val r = Text.Range(results.head.range.start, results.last.range.stop)
         val all_tips = (tips.filter(_._1) ++ tips.filter(!_._1).lastOption.toList).map(_._2)
         Some(Text.Info(r, Library.separate(Pretty.FBreak, all_tips)))
     }
   }
 
   val tooltip_margin: Int = options.int("jedit_tooltip_margin")
   val tooltip_bounds: Double = (options.real("jedit_tooltip_bounds") max 0.2) min 0.8
 
 
   def gutter_message(range: Text.Range): Option[Icon] =
   {
     val results =
       snapshot.cumulate_markup[Int](range, 0, Some(Set(Markup.WARNING, Markup.ERROR)), _ =>
         {
           case (pri, Text.Info(_, XML.Elem(Markup(Markup.WARNING, _), body))) =>
             body match {
               case List(XML.Elem(Markup(Markup.LEGACY, _), _)) =>
                 pri max Rendering.legacy_pri
               case _ => pri max Rendering.warning_pri
             }
           case (pri, Text.Info(_, XML.Elem(Markup(Markup.ERROR, _), _))) =>
             pri max Rendering.error_pri
         })
     val pri = (0 /: results) { case (p1, Text.Info(_, p2)) => p1 max p2 }
     Rendering.gutter_icons.get(pri)
   }
 
 
   private val squiggly_colors = Map(
     Rendering.writeln_pri -> writeln_color,
     Rendering.warning_pri -> warning_color,
     Rendering.error_pri -> error_color)
 
   def squiggly_underline(range: Text.Range): Stream[Text.Info[Color]] =
   {
     val results =
       snapshot.cumulate_markup[Int](range, 0,
         Some(Set(Markup.WRITELN, Markup.WARNING, Markup.ERROR)), _ =>
         {
           case (pri, Text.Info(_, XML.Elem(Markup(name, _), _)))
           if name == Markup.WRITELN ||
             name == Markup.WARNING ||
             name == Markup.ERROR => pri max Rendering.message_pri(name)
         })
     for {
       Text.Info(r, pri) <- results
       color <- squiggly_colors.get(pri)
     } yield Text.Info(r, color)
   }
 
 
   private val messages_include =
     Set(Markup.WRITELN_MESSAGE, Markup.TRACING_MESSAGE, Markup.WARNING_MESSAGE, Markup.ERROR_MESSAGE)
 
   private val message_colors = Map(
     Rendering.writeln_pri -> writeln_message_color,
     Rendering.tracing_pri -> tracing_message_color,
     Rendering.warning_pri -> warning_message_color,
     Rendering.error_pri -> error_message_color)
 
   def line_background(range: Text.Range): Option[(Color, Boolean)] =
   {
     val results =
       snapshot.cumulate_markup[Int](range, 0, Some(messages_include), _ =>
         {
           case (pri, Text.Info(_, XML.Elem(Markup(name, _), _)))
           if name == Markup.WRITELN_MESSAGE ||
             name == Markup.TRACING_MESSAGE ||
             name == Markup.WARNING_MESSAGE ||
             name == Markup.ERROR_MESSAGE => pri max Rendering.message_pri(name)
         })
     val pri = (0 /: results) { case (p1, Text.Info(_, p2)) => p1 max p2 }
 
     val is_separator = pri > 0 &&
       snapshot.cumulate_markup[Boolean](range, false, Some(Set(Markup.SEPARATOR)), _ =>
         {
           case (_, Text.Info(_, XML.Elem(Markup(Markup.SEPARATOR, _), _))) => true
         }).exists(_.info)
 
     message_colors.get(pri).map((_, is_separator))
   }
 
 
   def output_messages(st: Command.State): List[XML.Tree] =
   {
     st.results.entries.map(_._2).filterNot(Protocol.is_result(_)).toList
   }
 
 
   private val background1_include =
     Protocol.command_status_markup + Markup.WRITELN_MESSAGE + Markup.TRACING_MESSAGE +
       Markup.WARNING_MESSAGE + Markup.ERROR_MESSAGE + Markup.BAD + Markup.INTENSIFY ++
       active_include
 
   def background1(range: Text.Range): Stream[Text.Info[Color]] =
   {
     if (snapshot.is_outdated) Stream(Text.Info(range, outdated_color))
     else
       for {
         Text.Info(r, result) <-
           snapshot.cumulate_markup[(Option[Protocol.Status], Option[Color])](
             range, (Some(Protocol.Status.init), None), Some(background1_include), command_state =>
             {
               case (((Some(status), color), Text.Info(_, XML.Elem(markup, _))))
               if (Protocol.command_status_markup(markup.name)) =>
                 (Some(Protocol.command_status(status, markup)), color)
               case (_, Text.Info(_, XML.Elem(Markup(Markup.BAD, _), _))) =>
                 (None, Some(bad_color))
               case (_, Text.Info(_, XML.Elem(Markup(Markup.INTENSIFY, _), _))) =>
                 (None, Some(intensify_color))
               case (acc, Text.Info(_, Protocol.Dialog(_, serial, result))) =>
                 command_state.results.get(serial) match {
                   case Some(Protocol.Dialog_Result(res)) if res == result =>
                     (None, Some(active_result_color))
                   case _ =>
                     (None, Some(active_color))
                 }
               case (_, Text.Info(_, XML.Elem(markup, _))) if active_include(markup.name) =>
                 (None, Some(active_color))
             })
         color <-
           (result match {
             case (Some(status), opt_color) =>
               if (status.is_unprocessed) Some(unprocessed1_color)
               else if (status.is_running) Some(running1_color)
               else opt_color
             case (_, opt_color) => opt_color
           })
       } yield Text.Info(r, color)
   }
 
 
   def background2(range: Text.Range): Stream[Text.Info[Color]] =
     snapshot.select_markup(range, Some(Set(Markup.TOKEN_RANGE)), _ =>
       {
         case Text.Info(_, XML.Elem(Markup(Markup.TOKEN_RANGE, _), _)) => light_color
       })
 
 
   def bullet(range: Text.Range): Stream[Text.Info[Color]] =
     snapshot.select_markup(range, Some(Set(Markup.BULLET)), _ =>
       {
         case Text.Info(_, XML.Elem(Markup(Markup.BULLET, _), _)) => bullet_color
       })
 
 
   private val foreground_elements =
     Set(Markup.STRING, Markup.ALTSTRING, Markup.VERBATIM, Markup.ANTIQ)
 
   def foreground(range: Text.Range): Stream[Text.Info[Color]] =
     snapshot.select_markup(range, Some(foreground_elements), _ =>
       {
         case Text.Info(_, XML.Elem(Markup(Markup.STRING, _), _)) => quoted_color
         case Text.Info(_, XML.Elem(Markup(Markup.ALTSTRING, _), _)) => quoted_color
         case Text.Info(_, XML.Elem(Markup(Markup.VERBATIM, _), _)) => quoted_color
         case Text.Info(_, XML.Elem(Markup(Markup.ANTIQ, _), _)) => antiquoted_color
       })
 
 
   private val text_colors: Map[String, Color] = Map(
       Markup.KEYWORD1 -> keyword1_color,
       Markup.KEYWORD2 -> keyword2_color,
       Markup.STRING -> Color.BLACK,
       Markup.ALTSTRING -> Color.BLACK,
       Markup.VERBATIM -> Color.BLACK,
       Markup.LITERAL -> keyword1_color,
       Markup.DELIMITER -> Color.BLACK,
       Markup.TFREE -> tfree_color,
       Markup.TVAR -> tvar_color,
       Markup.FREE -> free_color,
       Markup.SKOLEM -> skolem_color,
       Markup.BOUND -> bound_color,
       Markup.VAR -> var_color,
       Markup.INNER_STRING -> inner_quoted_color,
       Markup.INNER_COMMENT -> inner_comment_color,
       Markup.DYNAMIC_FACT -> dynamic_color,
       Markup.ML_KEYWORD -> keyword1_color,
       Markup.ML_DELIMITER -> Color.BLACK,
       Markup.ML_NUMERAL -> inner_numeral_color,
       Markup.ML_CHAR -> inner_quoted_color,
       Markup.ML_STRING -> inner_quoted_color,
       Markup.ML_COMMENT -> inner_comment_color)
 
   private val text_color_elements = text_colors.keySet
 
   def text_color(range: Text.Range, color: Color)
       : Stream[Text.Info[Color]] =
   {
     if (color == Token_Markup.hidden_color) Stream(Text.Info(range, color))
     else
       snapshot.cumulate_markup(range, color, Some(text_color_elements), _ =>
         {
           case (_, Text.Info(_, XML.Elem(Markup(m, _), _)))
           if text_colors.isDefinedAt(m) => text_colors(m)
         })
   }
 
 
   /* nested text structure -- folds */
 
   private val fold_depth_include = Set(Markup.TEXT_FOLD, Markup.GOAL, Markup.SUBGOAL)
 
   def fold_depth(range: Text.Range): Stream[Text.Info[Int]] =
     snapshot.cumulate_markup[Int](range, 0, Some(fold_depth_include), _ =>
       {
         case (depth, Text.Info(_, XML.Elem(Markup(name, _), _)))
         if fold_depth_include(name) => depth + 1
       })
 }