Mercurial > hg > octave-lyh
view README @ 16485:8b783661e03f
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 | c49d891eb263 |
| children |
line wrap: on
line source
GNU Octave -- a high-level language for numerical computations. Copyright (C) 1996-2012 John W. Eaton Overview -------- GNU Octave is a high-level language, primarily intended for numerical computations. It provides a convenient command line interface for solving linear and nonlinear problems numerically. GNU Octave is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. GNU Octave is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the file COPYING for more details. Availability ------------ The latest released version of Octave is always available via anonymous ftp from ftp.gnu.org and its many mirror sites around the world. You may also find links to binary distributions at http://www.octave.org/download.html. The current development sources may be found on Savannah (http://savannah.gnu.org/projects/octave) under the Source Code tab. Installation ------------ Octave requires approximately 1.4 GB of disk storage to unpack and compile from source (significantly less, 400 MB, if you don't compile with debugging symbols). Once installed, Octave requires approximately 350MB of disk space (again, considerably less, 70 MB, if you don't build shared libraries or the binaries and libraries do not include debugging symbols). To compile Octave, you will need a recent version of GNU Make. You will also need a recent version of g++ or another ANSI C++ compiler. You will also need a Fortran 77 compiler or f2c. If you use f2c, you will need a script like fort77 that works like a normal Fortran compiler by combining f2c with your C compiler in a single script. YOU MUST HAVE GNU MAKE TO COMPILE OCTAVE. Octave's Makefiles use features of GNU Make that are not present in other versions of make. GNU Make is very portable and easy to install. See the notes in the files INSTALL and the system-specific README files in the etc directory of the Octave source distribution for more specific installation instructions. Bugs and Patches ---------------- The file BUGS explains the recommended procedure for reporting bugs or contributing patches. Documentation ------------- Octave's manual has been revised for version 3.4, but it is lagging a bit behind the development of the software. In particular, there is currently no complete documentation of the C++ class libraries. If you notice omissions or inconsistencies, please report them on the bug tracker at http://bugs.octave.org. Specific suggestions for ways to improve Octave and its documentation are always welcome. Reports with patches are even more welcome. Additional Information ---------------------- Up to date information about Octave is available on the WWW at the URL http://www.octave.org, including archives of the help, bug, and maintainers mailing lists. Last updated: Fri, 10 Jun 2011 14:02:32 EDT