src/Tools/jEdit/src/plugin.scala

 
   /* global changes */
 
   def options_changed()
   {
-    PIDE.session.global_options.post(Session.Global_Options(PIDE.options.value))
+    PIDE.session.global_options.post(Session.Global_Options(options.value))
     delay_load.invoke()
   }
 
   def deps_changed()
   {

 
 
   /* theory files */
 
   lazy val delay_init =
-    GUI_Thread.delay_last(PIDE.options.seconds("editor_load_delay"))
+    GUI_Thread.delay_last(options.seconds("editor_load_delay"))
     {
       init_models()
     }
 
   private val delay_load_active = Synchronized(false)

             (for ((node_name, model) <- models.iterator if model.is_theory)
               yield (node_name, Position.none)).toList
           val thy_files = PIDE.resources.thy_info.dependencies("", thys).deps.map(_.name)
 
           val aux_files =
-            if (PIDE.options.bool("jedit_auto_resolve")) {
+            if (options.bool("jedit_auto_resolve")) {
               val stable_tip_version =
                 if (models.forall(p => p._2.is_stable))
                   PIDE.session.current_state().stable_tip_version
                 else None
               stable_tip_version match {

       }
     }
   }
 
   private lazy val delay_load =
-    GUI_Thread.delay_last(PIDE.options.seconds("editor_load_delay")) { delay_load_action() }
+    GUI_Thread.delay_last(options.seconds("editor_load_delay")) { delay_load_action() }
 
   private def file_watcher_action(changed: Set[JFile]): Unit =
     if (Document_Model.sync_files(changed)) JEdit_Editor.invoke_generated()
 
   lazy val file_watcher: File_Watcher =
-    File_Watcher(file_watcher_action _, PIDE.options.seconds("editor_load_delay"))
+    File_Watcher(file_watcher_action _, options.seconds("editor_load_delay"))
 
 
   /* session phase */
 
   val session_phase_changed: Session.Phase => Unit =

         GUI.error_dialog(jEdit.getActiveView, "Prover process terminated",
           "Isabelle Syslog", GUI.scrollable_text(PIDE.session.syslog_content()))
       }
 
     case Session.Ready =>
-      PIDE.session.update_options(PIDE.options.value)
+      PIDE.session.update_options(options.value)
       init_models()
 
       if (!Isabelle.continuous_checking) {
         GUI_Thread.later {
           val answer =

             val buffer = edit_pane.getBuffer
             val text_area = edit_pane.getTextArea
             if (buffer != null && text_area != null) init_view(buffer, text_area)
           }
 
-          spell_checker.update(PIDE.options.value)
-          PIDE.session.update_options(PIDE.options.value)
+          spell_checker.update(options.value)
+          PIDE.session.update_options(options.value)
 
         case _ =>
       }
     }
   }

   {
     try {
       Debug.DISABLE_SEARCH_DIALOG_POOL = true
 
       completion_history.load()
-      spell_checker.update(PIDE.options.value)
+      spell_checker.update(options.value)
 
       SyntaxUtilities.setStyleExtender(new Token_Markup.Style_Extender)
       if (ModeProvider.instance.isInstanceOf[ModeProvider])
         ModeProvider.instance = new Token_Markup.Mode_Provider(ModeProvider.instance)
 

 
       val resources = new JEdit_Resources(JEdit_Sessions.session_base())
 
       PIDE.session.stop()
       PIDE.session = new Session(resources) {
-        override def output_delay = PIDE.options.seconds("editor_output_delay")
-        override def prune_delay = PIDE.options.seconds("editor_prune_delay")
-        override def syslog_limit = PIDE.options.int("editor_syslog_limit")
-        override def reparse_limit = PIDE.options.int("editor_reparse_limit")
+        override def output_delay = options.seconds("editor_output_delay")
+        override def prune_delay = options.seconds("editor_prune_delay")
+        override def syslog_limit = options.int("editor_syslog_limit")
+        override def reparse_limit = options.int("editor_reparse_limit")
       }
 
       startup_failure = None
     }
     catch {

   override def stop()
   {
     JEdit_Lib.jedit_text_areas.foreach(Completion_Popup.Text_Area.exit _)
 
     if (startup_failure.isEmpty) {
-      PIDE.options.value.save_prefs()
+      options.value.save_prefs()
       completion_history.value.save()
     }
 
     exit_models(JEdit_Lib.jedit_buffers().toList)
     PIDE.session.stop()