Mercurial > octave

diff libinterp/interpfcn/octave-link.h @ 16485:8b783661e03f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
improve exit sequence for GUI * octave-link.h, octave-link.cc (octave_link::accepting_events): Delete variable and all uses. (octave_link::link_enabled): New data member. (octave_link::octave_link): Don't set octave_exit. Initialize link_enabled. (octave_link::do_exit): Delete definition. Now pure virtual. Return bool. (octave_link::exit): Call instance->do_exit. (octave_link::enabled): New function. (ocave_link::process_events): New arg, disable. Optionally disable event processing. Use octave_link::enabled instead of instance_ok everywhere except for octave_link::exit. (octave_link::cleanup_instance): Delete. * octave-qt-link.h, octave-qt-link.cc (octave_qt_link::octave_qt_link): Accept thread as argument. Don't connect main_thread::finished signal. (octave_qt_link::~octave_qt_link): Don't delete main_thread. (octave_qt_link::do_exit): Emit exit_signal and return true. (octave_qt_link::exit_signal: New signal. (octave_qt_link::void octave_thread_finished_signal): Delete. * main-window.h, main-window.cc (main_window::_octave_main_thread): New member variable. (main_window::main_window): Initialize _octave_main_thread and _octave_qt_link to 0. (main_window::~main_window): Don't call octave_link::connect_link. Delete _octave_main_thread. (main_window::exit): Accept exit status as argument and call QApplication::exit instead of quit. (main_window::construct): Don't connect qApp::aboutToQuit to main_window::prepare_to_exit. (main_window::construct_octave_qt_link): Create _octave_main_thread and pass to _octave_qt_link. Don't connect _octave_qt_link::octave_thread_finished to main_window::exit. Connect _octave_qt_link::exit_signal to main_window::exit. * toplev.h, toplev.cc (main_loop): If quitting_gracefully, just return exit status instead of calling clean_up_and_exit. (do_octave_atexit): Now static. Call octave_link::process_events with disable arg set to true. (octave_atexit_functions): Now static. (clean_up_and_exit): New argument, safe_to_return. Call octave_link::exit and possibly return or wait for octave_link::exit to terminate the process. * octave.cc (octave_execute_interpreter): Don't alter return value from main_loop. Pass safe_to_return = true to clean_up_and_exit. Return retval instead of 0. (octave_initialize_interpreter): Don't call atexit.
author John W. Eaton <jwe@octave.org>
date Tue, 09 Apr 2013 23:08:24 -0400
parents 7a71ea0b7ae9
children 45ae1038ee89
line wrap: on
line diff
--- a/libinterp/interpfcn/octave-link.h	Tue Apr 09 23:08:21 2013 -0400
+++ b/libinterp/interpfcn/octave-link.h	Tue Apr 09 23:08:24 2013 -0400
@@ -53,118 +53,130 @@
 
   static void generate_events (void)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_generate_events ();
   }
 
-  static void process_events (void)
+  // If disable is TRUE, then no additional events will be processed
+  // other than exit.
+
+  static void process_events (bool disable = false)
   {
-    if (instance_ok ())
-      instance->do_process_events ();
+    if (enabled ())
+      {
+        if (disable)
+          instance->link_enabled = false;
+
+        instance->do_process_events ();
+      }
   }
 
   static void discard_events (void)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_discard_events ();
   }
 
-  static void exit (int status)
+  static bool exit (int status)
   {
+    bool retval = false;
+
     if (instance_ok ())
-      instance->do_exit (status);
+      retval = instance->do_exit (status);
+
+    return retval;
   }
 
   template <class T>
   static void post_event (T *obj, void (T::*method) (void))
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_post_event (obj, method);
   }
 
   template <class T, class A>
   static void post_event (T *obj, void (T::*method) (A), A arg)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_post_event (obj, method, arg);
   }
 
   template <class T, class A>
   static void post_event (T *obj, void (T::*method) (const A&), const A& arg)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_post_event (obj, method, arg);
   }
 
   static void entered_readline_hook (void)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_entered_readline_hook ();
   }
 
   static void finished_readline_hook (void)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_finished_readline_hook ();
   }
 
   static bool
   edit_file (const std::string& file)
   {
-    return instance_ok () ? instance->do_edit_file (file) : false;
+    return enabled () ? instance->do_edit_file (file) : false;
   }
 
   static void change_directory (const std::string& dir)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_change_directory (dir);
   }
 
   static void set_workspace (const std::list<workspace_element>& ws)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_set_workspace (ws);
   }
 
   static void clear_workspace (void)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_clear_workspace ();
   }
 
   static void set_history (const string_vector& hist)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_set_history (hist);
   }
 
   static void append_history (const std::string& hist_entry)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_append_history (hist_entry);
   }
 
   static void clear_history (void)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_clear_history ();
   }
 
   static void pre_input_event (void)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_pre_input_event ();
   }
 
   static void post_input_event (void)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_post_input_event ();
   }
 
   static void enter_debugger_event (const std::string& file, int line)
   {
-    if (instance_ok ())
+    if (enabled ())
       {
         instance->debugging = true;
 
@@ -174,13 +186,13 @@
 
   static void execute_in_debugger_event (const std::string& file, int line)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_execute_in_debugger_event (file, line);
   }
 
   static void exit_debugger_event (void)
   {
-    if (instance_ok () && instance->debugging)
+    if (enabled () && instance->debugging)
       {
         instance->debugging = false;
 
@@ -191,7 +203,7 @@
   static void
   update_breakpoint (bool insert, const std::string& file, int line)
   {
-    if (instance_ok ())
+    if (enabled ())
       instance->do_update_breakpoint (insert, file, line);
   }
 
@@ -201,15 +213,18 @@
 
   static octave_link *instance;
 
-  static void cleanup_instance (void) { delete instance; instance = 0; }
-
   // No copying!
 
   octave_link (const octave_link&);
 
   octave_link& operator = (const octave_link&);
 
-  static bool instance_ok (void);
+  static bool instance_ok (void) { return instance != 0; }
+
+  static bool enabled (void)
+  {
+    return instance_ok () ? instance->link_enabled : false;
+  }
 
 protected:
 
@@ -220,39 +235,35 @@
   event_queue gui_event_queue;
 
   bool debugging;
-
-  bool accepting_events;
+  bool link_enabled;
 
   void do_generate_events (void);
   void do_process_events (void);
   void do_discard_events (void);
 
-  void do_exit (int status);
-
   template <class T>
   void do_post_event (T *obj, void (T::*method) (void))
   {
-    if (accepting_events)
-      gui_event_queue.add_method (obj, method);
+    gui_event_queue.add_method (obj, method);
   }
 
   template <class T, class A>
   void do_post_event (T *obj, void (T::*method) (A), A arg)
   {
-    if (accepting_events)
-      gui_event_queue.add_method (obj, method, arg);
+    gui_event_queue.add_method (obj, method, arg);
   }
 
   template <class T, class A>
   void do_post_event (T *obj, void (T::*method) (const A&), const A& arg)
   {
-    if (accepting_events)
-      gui_event_queue.add_method (obj, method, arg);
+    gui_event_queue.add_method (obj, method, arg);
   }
 
   void do_entered_readline_hook (void) { }
   void do_finished_readline_hook (void) { }
 
+  virtual bool do_exit (int status) = 0;
+
   virtual bool do_edit_file (const std::string& file) = 0;
 
   virtual void do_change_directory (const std::string& dir) = 0;