From ee7a1321a7e1538db895c77307a8dc021248f315 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Lars=20Gullik=20Bj=C3=B8nnes?= Date: Tue, 29 May 2001 09:50:02 +0000 Subject: [PATCH] better key handling, move some methods closer to caller, fix in lyxstring, change lyxsum to use istream_iterator git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@2032 a592a061-630c-0410-9148-cb99ea01b6c8 --- boost/ChangeLog | 8 + boost/boost/config.hpp | 149 ++++- boost/boost/smart_ptr.hpp | 18 +- boost/boost/utility.hpp | 41 +- lib/ChangeLog | 4 + lib/bind/latinkeys.bind | 17 + src/BufferView.h | 14 - src/BufferView2.C | 88 +-- src/BufferView_pimpl.C | 1041 +++++++++++++++++++++------------ src/BufferView_pimpl.h | 14 + src/ChangeLog | 12 + src/insets/insetspecialchar.C | 2 +- src/lyx_main.C | 37 +- src/lyxfunc.C | 106 +--- src/support/ChangeLog | 8 + src/support/lyxstring.C | 5 + src/support/lyxsum.C | 18 +- 17 files changed, 953 insertions(+), 629 deletions(-) diff --git a/boost/ChangeLog b/boost/ChangeLog index dae2793cf8..423418b66e 100644 --- a/boost/ChangeLog +++ b/boost/ChangeLog @@ -1,3 +1,11 @@ +2001-05-29 Lars Gullik Bjønnes + + * boost/utility.hpp: update + + * boost/smart_ptr.hpp: update... not finished + + * boost/config.hpp: update + 2001-04-17 Lars Gullik Bjønnes * boost/array.hpp: move array back into namespace boost diff --git a/boost/boost/config.hpp b/boost/boost/config.hpp index 334c6f532e..9b7ebb409b 100644 --- a/boost/boost/config.hpp +++ b/boost/boost/config.hpp @@ -11,6 +11,13 @@ // http://www.boost.org/libs/config // Revision History (excluding minor changes for specific compilers) +// 16 Mar 01 Added BOOST_VERSION (Jens Maurer) +// 06 Mar 01 Refactored EDG checks for Intel C++ (Dave Abrahams) +// 04 Mar 01 Factored EDG checks, added BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP +// for Intel C++ 5.0 (Dave Abrahams) +// 17 Feb 01 BOOST_NO_CV_SPECIALIZATIONS +// BOOST_NO_CV_VOID_SPECIALIZATIONS (John Maddock) +// 11 Feb 01 Added BOOST_STATIC_CONSTANT (Dave Abrahams) // 20 Jan 01 BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS moved here from // cast.hpp. Added missing BOOST_NO_STRINGSTREAM which some // boost code seemed to depend on. (Dave Abrahams) @@ -51,6 +58,13 @@ #ifndef BOOST_CONFIG_HPP #define BOOST_CONFIG_HPP +#define BOOST_VERSION 102200 + +// BOOST_VERSION % 100 is the sub-minor version +// BOOST_VERSION / 100 % 1000 is the minor version +// BOOST_VERSION / 100000 is the major version + + // Conformance Flag Macros -------------------------------------------------// // // Conformance flag macros should identify the absence of C++ Standard @@ -59,6 +73,12 @@ // burden where it should be, on non-conforming compilers. In the future, // hopefully, less rather than more conformance flags will have to be defined. +// BOOST_NO_CV_SPECIALIZATIONS: if template specialisations for cv-qualified types +// conflict with a specialistaion for unqualififed type. + +// BOOST_NO_CV_VOID_SPECIALIZATIONS: if template specialisations for cv-void types +// conflict with a specialistaion for void. + // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP: Compiler does not implement // argument-dependent lookup (also named Koenig lookup); see std::3.4.2 // [basic.koenig.lookup] @@ -194,6 +214,18 @@ // BOOST_NO_STD_MIN_MAX: The C++ standard library does not provide // the min() and max() template functions that should be in . +// Common compiler front-ends precede all compiler checks ------------------// + +// Edison Design Group front-ends +# if defined(__EDG_VERSION__) + +# if __EDG_VERSION__ <= 241 +# define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP +# endif + +# endif + +// Compiler-specific checks -------------------------------------------------// // Compilers are listed in alphabetic order (except VC++ last - see below)---// // GNU CC (also known as GCC and G++) --------------------------------------// @@ -203,9 +235,11 @@ // egcs 1.1 won't parse smart_ptr.hpp without this: # define BOOST_NO_AUTO_PTR # endif -# if __GNUC__ == 2 && __GNUC_MINOR__ <= 95 -# include // not sure this is the right way to do this -JGS -# if !defined(_CXXRT_STD) && !defined(__SGI_STL) // need to ask Dietmar about this -JGS +# if __GNUC__ == 2 && __GNUC_MINOR__ <= 97 +# include // not sure this is the right way to do this -JGS +# if defined(__BASTRING__) && !defined(__GLIBCPP__) && !defined(_CXXRT_STD) && !defined(__SGI_STL) // need to ask Dietmar about this -JGS + // this should only detect the stdlibc++ that ships with gcc, and + // not any replacements that may be installed... # define BOOST_NO_STD_ITERATOR # define BOOST_NO_LIMITS # endif @@ -218,7 +252,7 @@ # if __GNUC__ == 2 && __GNUC_MINOR__ <= 8 # define BOOST_NO_MEMBER_TEMPLATES # endif -# if (__GNUC__ == 2 && __GNUC_MINOR__ > 95) || __GNUC__ > 2 +# if (__GNUC__ == 2 && __GNUC_MINOR__ > 97) || __GNUC__ > 2 // upcoming gcc 3.0 # include # if defined(__GLIBCPP__) @@ -229,7 +263,16 @@ # endif # endif -// Kai C++ ------------------------------------------------------------------// +// Intel on Linux --------------------------------------------------------- + +#elif defined __ICC +# include +# ifdef _CPPLIB_VER + // shipped with Dinkumware 3.10, which has a different hash_map +# define BOOST_NO_HASH +# endif + +// Kai C++ ---------------------------------------------------------------- #elif defined __KCC # define BOOST_NO_SLIST @@ -244,17 +287,11 @@ #elif defined __sgi -# if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 240 -# define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP -# endif - // Compaq Tru64 Unix cxx --------------------------------------------------- #elif defined __DECCXX - -# if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 240 -# define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP -# endif +# define BOOST_NO_SLIST +# define BOOST_NO_HASH // Greenhills C++ -----------------------------------------------------------// @@ -267,6 +304,8 @@ #elif defined __BORLANDC__ # define BOOST_NO_SLIST # define BOOST_NO_HASH +// pull in standard library version: +# include # if __BORLANDC__ <= 0x0551 # define BOOST_NO_INTEGRAL_INT64_T # define BOOST_NO_PRIVATE_IN_AGGREGATE @@ -290,8 +329,16 @@ # else # define BOOST_DECL # endif +#if (__BORLANDC__ == 0x550) || (__BORLANDC__ == 0x551) +// is partly broken, some macos define symbols that are really in +// namespace std, so you end up having to use illegal constructs like +// std::DBL_MAX, as a fix we'll just include float.h and have done with: +#include +#endif +# define BOOST_NO_CV_SPECIALIZATIONS +# define BOOST_NO_CV_VOID_SPECIALIZATIONS -// Intel -------------------------------------------------------------------// +// Intel on Windows --------------------------------------------------------// # elif defined __ICL # include // not sure this is the right way to do this -JGS @@ -299,6 +346,13 @@ // a perfectly good implementation of std::iterator is supplied # elif defined(__SGI_STL_ITERATOR) # define BOOST_NO_STD_ITERATOR // No std::iterator in this case +# elif defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306) +# // full dinkumware 3.06 and above +# define BOOST_NO_HASH +# define BOOST_NO_STD_ITERATOR_TRAITS +# if !_GLOBAL_USING // can be defined in yvals.h +# define BOOST_NO_STDC_NAMESPACE +# endif # else // assume using dinkumware's STL that comes with VC++ 6.0 # define BOOST_MSVC_STD_ITERATOR # define BOOST_NO_STD_ITERATOR_TRAITS @@ -309,16 +363,17 @@ # define BOOST_NO_STD_ALLOCATOR # define BOOST_NO_STD_MIN_MAX # endif - +# define BOOST_NO_INTRINSIC_WCHAR_T // tentative addition - required for VC6 compatibility? (added by JM 19 Feb 2001) // Metrowerks CodeWarrior --------------------------------------------------// # elif defined __MWERKS__ -# if __MWERKS__ <= 0x4000 +# if __MWERKS__ <= 0x2401 // 6.2 # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS # endif -# if __MWERKS__ <= 0x2301 +# if __MWERKS__ <= 0x2301 // 5.3? # define BOOST_NO_POINTER_TO_MEMBER_CONST +# define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS # endif # if __MWERKS__ >= 0x2300 # define BOOST_SYSTEM_HAS_STDINT_H @@ -336,20 +391,41 @@ # define BOOST_STD_EXTENSION_NAMESPACE Metrowerks -// Sun Workshop Compiler C++ ------------------------------------------------// +// Sun Workshop Compiler C++ ------------------------------------------------ # elif defined __SUNPRO_CC # if __SUNPRO_CC <= 0x520 # define BOOST_NO_SLIST # define BOOST_NO_HASH # define BOOST_NO_STD_ITERATOR_TRAITS + // although sunpro 5.1 supports the syntax for + // inline initialization it often gets the value + // wrong, especially where the value is computed + // from other constants (J Maddock 6th May 2001) +# define BOOST_NO_INCLASS_MEMBER_INITIALIZATION + // although sunpro 5.1 supports the syntax for + // partial specialization, it often seems to + // bind to the wrong specialization. Better + // to disable it until suppport becomes more stable + // (J Maddock 6th May 2001). +# define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # endif # if __SUNPRO_CC <= 0x500 # define BOOST_NO_MEMBER_TEMPLATES # define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # endif -// Microsoft Visual C++ (excluding Intel/EDG front end) --------------------// + +// HP aCC ------------------------------------------------------------------- + +# elif defined __HP_aCC +# define BOOST_NO_SLIST +# define BOOST_NO_HASH +# define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS +# define BOOST_NO_OPERATORS_IN_NAMESPACE + // (support for HP aCC is not complete, see the regression test results) + +// Microsoft Visual C++ (excluding Intel/EDG front end) -------------------- // // Must remain the last #elif since some other vendors (Metrowerks, for // example) also #define _MSC_VER @@ -384,6 +460,13 @@ // a perfectly good implementation of std::iterator is supplied # elif defined(__SGI_STL_ITERATOR) # define BOOST_NO_STD_ITERATOR // No std::iterator in this case +# elif defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306) + // full dinkumware 3.06 and above +# define BOOST_NO_HASH +# define BOOST_NO_STD_ITERATOR_TRAITS +# ifndef _GLOBAL_USING // can be defined in yvals.h +# define BOOST_NO_STDC_NAMESPACE +# endif # else # define BOOST_MSVC_STD_ITERATOR 1 # define BOOST_NO_SLIST @@ -403,6 +486,7 @@ # endif # endif # define BOOST_NO_STD_ITERATOR_TRAITS +# define BOOST_NO_CV_VOID_SPECIALIZATIONS // Make sure at least one standard library header is included so that library @@ -437,19 +521,22 @@ // end of compiler specific portion ----------------------------------------// -#if defined(BOOST_NO_LIMITS) || \ - (defined(_RWSTD_VER) && _RWSTD_VER < 0x0203) || \ - (defined(__SGI_STL_PORT) && __SGI_STL_PORT <= 0x410 && __STL_STATIC_CONST_INIT_BUG) +#if defined(BOOST_NO_LIMITS) || (defined(_RWSTD_VER) && defined(__BORLANDC__) && _RWSTD_VER < 0x020300) || (defined(__SGI_STL_PORT) && __SGI_STL_PORT <= 0x410 && defined(__STL_STATIC_CONST_INIT_BUG)) // STLPort 4.0 doesn't define the static constants in numeric_limits<> so that they // can be used at compile time if the compiler bug indicated by // __STL_STATIC_CONST_INIT_BUG is present. // Rogue wave STL (C++ Builder) also has broken numeric_limits // with default template defining members out of line. -// However, Compaq C++ also uses RogueWave (version 2.03) and it's ok. +// However, Compaq C++ also uses RogueWave (version 0x0203) and it's ok. # define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS #endif +#if defined(__hpux) +// HP-UX has a nice stdint.h in a different location, see boost/cstdint.hpp +# define BOOST_SYSTEM_HAS_STDINT_H +#endif + #ifndef BOOST_STD_EXTENSION_NAMESPACE # define BOOST_STD_EXTENSION_NAMESPACE std #endif @@ -497,5 +584,21 @@ namespace std { } #endif +// BOOST_STATIC_CONSTANT workaround --------------------------------------- // +// On compilers which don't allow in-class initialization of static integral +// constant members, we must use enums as a workaround if we want the constants +// to be available at compile-time. This macro gives us a convenient way to +// declare such constants. +#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION +# define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment } +#else +# define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment +#endif + #endif // BOOST_CONFIG_HPP + + + + + diff --git a/boost/boost/smart_ptr.hpp b/boost/boost/smart_ptr.hpp index 6b03d49f35..af7cf9856b 100644 --- a/boost/boost/smart_ptr.hpp +++ b/boost/boost/smart_ptr.hpp @@ -17,6 +17,10 @@ // See http://www.boost.org for most recent version including documentation. // Revision History +// 21 May 01 Require complete type where incomplete type is unsafe. +// (suggested by Vladimir Prus) +// 21 May 01 operator= fails if operand transitively owned by *this, as in a +// linked list (report by Ken Johnson, fix by Beman Dawes) // 21 Jan 01 Suppress some useless warnings with MSVC (David Abrahams) // 19 Oct 00 Make shared_ptr ctor from auto_ptr explicit. (Robert Vugts) // 24 Jul 00 Change throw() to // never throws. See lib guidelines @@ -60,13 +64,19 @@ #include // for std::size_t #include // for std::auto_ptr #include // for std::swap -#include // for boost::noncopyable +#include // for boost::noncopyable, checked_delete, checked_array_delete #include // for std::less +#include // for BOOST_STATIC_ASSERT #ifdef LYX_NO_EXCEPTIONS #include #endif +#ifdef BOOST_MSVC // moved here to work around VC++ compiler crash +# pragma warning(push) +# pragma warning(disable:4284) // return type for 'identifier::operator->' is not a UDT or reference to a UDT. Will produce errors if applied using infix notation +#endif + namespace boost { // scoped_ptr --------------------------------------------------------------// @@ -84,9 +94,9 @@ template class scoped_ptr : noncopyable { typedef T element_type; explicit scoped_ptr( T* p=0 ) : ptr(p) {} // never throws - ~scoped_ptr() { delete ptr; } - - void reset( T* p=0 ) { if ( ptr != p ) { delete ptr; ptr = p; } } + ~scoped_ptr() { checked_delete(ptr); } + void reset( T* p=0 ) { if ( ptr != p ) { checked_delete(ptr); ptr = +p; } } T& operator*() const { return *ptr; } // never throws #ifdef BOOST_MSVC # pragma warning(push) diff --git a/boost/boost/utility.hpp b/boost/boost/utility.hpp index 82a7d13219..5942fb902f 100644 --- a/boost/boost/utility.hpp +++ b/boost/boost/utility.hpp @@ -11,6 +11,9 @@ // Classes appear in alphabetical order // Revision History +// 21 May 01 checked_delete() and checked_array_delete() added (Beman Dawes, +// suggested by Dave Abrahams, generalizing idea from Vladimir Prus) +// 21 May 01 made next() and prior() inline (Beman Dawes) // 26 Jan 00 protected noncopyable destructor added (Miki Jovanovic) // 10 Dec 99 next() and prior() templates added (Dave Abrahams) // 30 Aug 99 moved cast templates to cast.hpp (Beman Dawes) @@ -22,12 +25,40 @@ #ifndef BOOST_UTILITY_HPP #define BOOST_UTILITY_HPP -#include -#include // for size_t -#include // for std::pair +#include // broken compiler workarounds +#include +#include // for size_t +#include // for std::pair namespace boost { +// checked_delete() and checked_array_delete() -----------------------------// + + // verify that types are complete for increased safety + + template< typename T > + inline void checked_delete(T * x) + { +# if !((defined(__BORLANDC__) && __BORLANDC__ <= 0x0551) || (defined(__ICL) && __ICL <= 500)) + BOOST_STATIC_ASSERT( sizeof(T) ); // assert type complete at point + // of instantiation +# else + sizeof(T); // force error if type incomplete +# endif + delete x; + } + + template< typename T > + inline void checked_array_delete(T * x) + { +# if !((defined(__BORLANDC__) && __BORLANDC__ <= 0x0551) || (defined(__ICL) && __ICL <= 500)) + BOOST_STATIC_ASSERT( sizeof(T) ); // assert type complete at point + // of instantiation +# else + sizeof(T); // force error if type incomplete +# endif + delete [] x; + } // next() and prior() template functions -----------------------------------// @@ -41,10 +72,10 @@ namespace boost // Contributed by Dave Abrahams template - T next(T x) { return ++x; } + inline T next(T x) { return ++x; } template - T prior(T x) { return --x; } + inline T prior(T x) { return --x; } // class noncopyable -------------------------------------------------------// diff --git a/lib/ChangeLog b/lib/ChangeLog index 8164cd9887..8f687f4663 100644 --- a/lib/ChangeLog +++ b/lib/ChangeLog @@ -1,3 +1,7 @@ +2001-05-29 Lars Gullik Bjønnes + + * bind/latinkeys.bind: add some bindings for KP_ keys. + 2001-05-23 Lars Gullik Bjønnes * bind/latinkeys.bind: set quotedbl to quote-insert, set diff --git a/lib/bind/latinkeys.bind b/lib/bind/latinkeys.bind index c231c19bf7..9b9f9aabdf 100644 --- a/lib/bind/latinkeys.bind +++ b/lib/bind/latinkeys.bind @@ -1,3 +1,20 @@ +# KP_ keys. Should possibly be moved to another file + +\bind "KP_0" "self-insert 0" +\bind "KP_1" "self-insert 1" +\bind "KP_2" "self-insert 2" +\bind "KP_3" "self-insert 3" +\bind "KP_4" "self-insert 4" +\bind "KP_5" "self-insert 5" +\bind "KP_6" "self-insert 6" +\bind "KP_7" "self-insert 7" +\bind "KP_8" "self-insert 8" +\bind "KP_9" "self-insert 9" +\bind "KP_Decimal" "self-insert ." +\bind "KP_Add" "self-insert +" +\bind "KP_Divide" "self-insert /" +\bind "KP_Multiply" "self-insert *" +\bind "KP_Subtract" "self-insert -" # Latin 1 diff --git a/src/BufferView.h b/src/BufferView.h index 2215b08f7a..63e3425663 100644 --- a/src/BufferView.h +++ b/src/BufferView.h @@ -151,20 +151,6 @@ public: /// void copyEnvironment(); /// - void hfill(); - /// - void protectedBlank(LyXText *); - /// - void newline(); - /// - void menuSeparator(); - /// - void endOfSentenceDot(); - /// - void ldots(); - /// - void hyphenationPoint(); - /// void menuUndo(); /// void menuRedo(); diff --git a/src/BufferView2.C b/src/BufferView2.C index d24181d065..947bd25a8f 100644 --- a/src/BufferView2.C +++ b/src/BufferView2.C @@ -20,7 +20,6 @@ #include "lyxtext.h" #include "insets/inseterror.h" #include "insets/insetinfo.h" -#include "insets/insetspecialchar.h" #include "LyXView.h" #include "bufferlist.h" #include "support/FileInfo.h" @@ -44,6 +43,7 @@ using std::find; using std::count; using std::count_if; + // Inserts a file into current document bool BufferView::insertLyXFile(string const & filen) // @@ -313,91 +313,6 @@ void BufferView::menuRedo() } -void BufferView::hyphenationPoint() -{ - if (available()) { - hideCursor(); - update(text, BufferView::SELECT|BufferView::FITCUR); - InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::HYPHENATION); - insertInset(new_inset); - } -} - - -void BufferView::ldots() -{ - if (available()) { - hideCursor(); - update(text, BufferView::SELECT|BufferView::FITCUR); - InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::LDOTS); - insertInset(new_inset); - } -} - - -void BufferView::endOfSentenceDot() -{ - if (available()) { - hideCursor(); - update(text, BufferView::SELECT|BufferView::FITCUR); - InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::END_OF_SENTENCE); - insertInset(new_inset); - } -} - - -void BufferView::menuSeparator() -{ - if (available()) { - hideCursor(); - update(text, BufferView::SELECT|BufferView::FITCUR); - InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::MENU_SEPARATOR); - insertInset(new_inset); - } -} - - -void BufferView::newline() -{ - if (available()) { - hideCursor(); - update(text, BufferView::SELECT|BufferView::FITCUR); - text->InsertChar(this, LyXParagraph::META_NEWLINE); - update(text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - } -} - - -void BufferView::protectedBlank(LyXText * lt) -{ - if (available()) { - hideCursor(); - update(lt, BufferView::SELECT|BufferView::FITCUR); - InsetSpecialChar * new_inset = - new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); - if (!insertInset(new_inset)) - delete new_inset; - else - updateInset(new_inset, true); - } -} - - -void BufferView::hfill() -{ - if (available()) { - hideCursor(); - update(text, BufferView::SELECT|BufferView::FITCUR); - text->InsertChar(this, LyXParagraph::META_HFILL); - update(text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - } -} - - void BufferView::copyEnvironment() { if (available()) { @@ -433,6 +348,7 @@ void BufferView::copy() } } + void BufferView::cut() { if (available()) { diff --git a/src/BufferView_pimpl.C b/src/BufferView_pimpl.C index 6738a2bcd0..66fd7fc535 100644 --- a/src/BufferView_pimpl.C +++ b/src/BufferView_pimpl.C @@ -55,6 +55,7 @@ #include "insets/insettheorem.h" #include "insets/insetcaption.h" #include "insets/insetfloatlist.h" +#include "insets/insetspecialchar.h" #include "mathed/formulamacro.h" #include "gettext.h" @@ -1325,17 +1326,19 @@ void BufferView::Pimpl::stuffClipboard(string const & stuff) const * Dispatch functions for actions which can be valid for BufferView->text * and/or InsetText->text!!! */ -static LyXText * TEXT(BufferView * bv) { return bv->getLyXText(); } + inline void BufferView::Pimpl::moveCursorUpdate(bool selecting) { - if (selecting || TEXT(bv_)->mark_set) { - TEXT(bv_)->SetSelection(bv_); - if (TEXT(bv_)->bv_owner) + LyXText * lt = bv_->getLyXText(); + + if (selecting || lt->mark_set) { + lt->SetSelection(bv_); + if (lt->bv_owner) bv_->toggleToggle(); } - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); + update(lt, BufferView::SELECT|BufferView::FITCUR); showCursor(); /* ---> Everytime the cursor is moved, show the current font state. */ @@ -1347,7 +1350,7 @@ void BufferView::Pimpl::moveCursorUpdate(bool selecting) Inset * BufferView::Pimpl::getInsetByCode(Inset::Code code) { - LyXCursor cursor = TEXT(bv_)->cursor; + LyXCursor cursor = bv_->getLyXText()->cursor; Buffer::inset_iterator it = find_if(Buffer::inset_iterator( cursor.par(), cursor.pos()), @@ -1373,12 +1376,17 @@ void BufferView::Pimpl::MenuInsertLyXFile(string const & filen) initpath = trypath; } - FileDialog fileDlg(bv_->owner(), _("Select LyX document to insert"), + FileDialog fileDlg(bv_->owner(), + _("Select LyX document to insert"), LFUN_FILE_INSERT, - make_pair(string(_("Documents")), string(lyxrc.document_path)), - make_pair(string(_("Examples")), string(AddPath(system_lyxdir, "examples")))); - - FileDialog::Result result = fileDlg.Select(initpath, _("*.lyx| LyX Documents (*.lyx)")); + make_pair(string(_("Documents")), + string(lyxrc.document_path)), + make_pair(string(_("Examples")), + string(AddPath(system_lyxdir, "examples")))); + + FileDialog::Result result = + fileDlg.Select(initpath, + _("*.lyx| LyX Documents (*.lyx)")); if (result.first == FileDialog::Later) return; @@ -1420,11 +1428,17 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) switch (action) { // --- Misc ------------------------------------------- case LFUN_APPENDIX: + { if (available()) { - TEXT(bv_)->toggleAppendix(bv_); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + LyXText * lt = bv_->getLyXText(); + lt->toggleAppendix(bv_); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } - break; + } + break; case LFUN_TOC_INSERT: { @@ -1504,35 +1518,35 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) } case LFUN_HYPHENATION: - bv_->hyphenationPoint(); + hyphenationPoint(); break; case LFUN_LDOTS: - bv_->ldots(); + ldots(); break; case LFUN_END_OF_SENTENCE: - bv_->endOfSentenceDot(); + endOfSentenceDot(); break; case LFUN_MENU_SEPARATOR: - bv_->menuSeparator(); + menuSeparator(); break; case LFUN_HFILL: - bv_->hfill(); + hfill(); break; case LFUN_DEPTH: - changeDepth(bv_, TEXT(bv_), 0); + changeDepth(bv_, bv_->getLyXText(), 0); break; case LFUN_DEPTH_MIN: - changeDepth(bv_, TEXT(bv_), -1); + changeDepth(bv_, bv_->getLyXText(), -1); break; case LFUN_DEPTH_PLUS: - changeDepth(bv_, TEXT(bv_), 1); + changeDepth(bv_, bv_->getLyXText(), 1); break; case LFUN_FREE: @@ -1589,14 +1603,18 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) } if (current_layout != layout.second) { + LyXText * lt = bv_->getLyXText(); hideCursor(); current_layout = layout.second; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->SetLayout(bv_, layout.second); + update(lt, + BufferView::SELECT + | BufferView::FITCUR); + lt->SetLayout(bv_, layout.second); owner_->setLayout(layout.second); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); setState(); } } @@ -1658,37 +1676,67 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) break; case LFUN_UPCASE_WORD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->ChangeWordCase(bv_, LyXText::text_uppercase); - if (TEXT(bv_)->inset_owner) - bv_->updateInset(TEXT(bv_)->inset_owner, true); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - break; + { + LyXText * lt = bv_->getLyXText(); + + update(lt, + BufferView::SELECT + | BufferView::FITCUR); + lt->ChangeWordCase(bv_, LyXText::text_uppercase); + if (lt->inset_owner) + bv_->updateInset(lt->inset_owner, true); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } + break; case LFUN_LOWCASE_WORD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->ChangeWordCase(bv_, LyXText::text_lowercase); - if (TEXT(bv_)->inset_owner) - bv_->updateInset(TEXT(bv_)->inset_owner, true); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - break; + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->ChangeWordCase(bv_, LyXText::text_lowercase); + if (lt->inset_owner) + bv_->updateInset(lt->inset_owner, true); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } + break; case LFUN_CAPITALIZE_WORD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->ChangeWordCase(bv_, - LyXText::text_capitalization); - if (TEXT(bv_)->inset_owner) - bv_->updateInset(TEXT(bv_)->inset_owner, true); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - break; + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->ChangeWordCase(bv_, + LyXText::text_capitalization); + if (lt->inset_owner) + bv_->updateInset(lt->inset_owner, true); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } + break; case LFUN_TRANSPOSE_CHARS: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->TransposeChars(*bv_); - if (TEXT(bv_)->inset_owner) - bv_->updateInset(TEXT(bv_)->inset_owner, true); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - break; + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->TransposeChars(*bv_); + if (lt->inset_owner) + bv_->updateInset(lt->inset_owner, true); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } + break; case LFUN_INSERT_LABEL: @@ -1744,33 +1792,35 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) // --- Cursor Movements ----------------------------- case LFUN_RIGHT: { - bool is_rtl = TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params); - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); + LyXText * lt = bv_->getLyXText(); + + bool is_rtl = lt->cursor.par()->isRightToLeftPar(buffer_->params); + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); if (is_rtl) - TEXT(bv_)->CursorLeft(bv_, false); - if (TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->size() - && TEXT(bv_)->cursor.par()->GetChar(TEXT(bv_)->cursor.pos()) + lt->CursorLeft(bv_, false); + if (lt->cursor.pos() < lt->cursor.par()->size() + && lt->cursor.par()->GetChar(lt->cursor.pos()) == LyXParagraph::META_INSET - && TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos()) - && TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE){ - Inset * tmpinset = TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos()); + && lt->cursor.par()->GetInset(lt->cursor.pos()) + && lt->cursor.par()->GetInset(lt->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE){ + Inset * tmpinset = lt->cursor.par()->GetInset(lt->cursor.pos()); owner_->getLyXFunc()->setMessage(tmpinset->EditMessage()); int y = 0; if (is_rtl) { LyXFont const font = - TEXT(bv_)->GetFont(buffer_, - TEXT(bv_)->cursor.par(), - TEXT(bv_)->cursor.pos()); + lt->GetFont(buffer_, + lt->cursor.par(), + lt->cursor.pos()); y = tmpinset->descent(bv_,font); } tmpinset->Edit(bv_, 0, y, 0); break; } if (!is_rtl) - TEXT(bv_)->CursorRight(bv_, false); - TEXT(bv_)->FinishUndo(); + lt->CursorRight(bv_, false); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); } @@ -1780,26 +1830,27 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) { // This is soooo ugly. Isn`t it possible to make // it simpler? (Lgb) - bool is_rtl = TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params); - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - LyXCursor cur = TEXT(bv_)->cursor; + LyXText * lt = bv_->getLyXText(); + bool is_rtl = lt->cursor.par()->isRightToLeftPar(buffer_->params); + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); + LyXCursor const & cur = lt->cursor; if (!is_rtl) - TEXT(bv_)->CursorLeft(bv_, false); - if ((is_rtl || cur != TEXT(bv_)->cursor) && // only if really moved! - TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->size() && - (TEXT(bv_)->cursor.par()->GetChar(TEXT(bv_)->cursor.pos()) == + lt->CursorLeft(bv_, false); + if ((is_rtl || cur != lt->cursor) && // only if really moved! + lt->cursor.pos() < lt->cursor.par()->size() && + (lt->cursor.par()->GetChar(lt->cursor.pos()) == LyXParagraph::META_INSET) && - TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos()) && - (TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos())->Editable() + lt->cursor.par()->GetInset(lt->cursor.pos()) && + (lt->cursor.par()->GetInset(lt->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE)) { - Inset * tmpinset = TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos()); + Inset * tmpinset = lt->cursor.par()->GetInset(lt->cursor.pos()); owner_->getLyXFunc()->setMessage(tmpinset->EditMessage()); - LyXFont font = TEXT(bv_)->GetFont(buffer_, - TEXT(bv_)->cursor.par(), - TEXT(bv_)->cursor.pos()); + LyXFont const font = lt->GetFont(buffer_, + lt->cursor.par(), + lt->cursor.pos()); int y = is_rtl ? 0 : tmpinset->descent(bv_,font); tmpinset->Edit(bv_, @@ -1809,342 +1860,465 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) break; } if (is_rtl) - TEXT(bv_)->CursorRight(bv_, false); + lt->CursorRight(bv_, false); - TEXT(bv_)->FinishUndo(); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); } break; case LFUN_UP: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - TEXT(bv_)->CursorUp(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::UPDATE); + lt->CursorUp(bv_); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_DOWN: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - TEXT(bv_)->CursorDown(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::UPDATE); + lt->CursorDown(bv_); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_UP_PARAGRAPH: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - TEXT(bv_)->CursorUpParagraph(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::UPDATE); + lt->CursorUpParagraph(bv_); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_DOWN_PARAGRAPH: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - TEXT(bv_)->CursorDownParagraph(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::UPDATE); + lt->CursorDownParagraph(bv_); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_PRIOR: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - cursorPrevious(TEXT(bv_)); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::UPDATE); + cursorPrevious(lt); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_NEXT: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::UPDATE); - cursorNext(TEXT(bv_)); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::UPDATE); + cursorNext(lt); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_HOME: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorHome(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->CursorHome(bv_); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_END: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorEnd(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorEnd(bv_); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_SHIFT_TAB: case LFUN_TAB: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorTab(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorTab(bv_); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_WORDRIGHT: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorLeftOneWord(bv_); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->CursorLeftOneWord(bv_); else - TEXT(bv_)->CursorRightOneWord(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorRightOneWord(bv_); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_WORDLEFT: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorRightOneWord(bv_); + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->CursorRightOneWord(bv_); else - TEXT(bv_)->CursorLeftOneWord(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorLeftOneWord(bv_); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_BEGINNINGBUF: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorTop(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorTop(bv_); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; + } + break; case LFUN_ENDBUF: - if (!TEXT(bv_)->mark_set) - beforeChange(TEXT(bv_)); - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->mark_set) + beforeChange(lt); + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorBottom(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorBottom(bv_); + lt->FinishUndo(); moveCursorUpdate(false); owner_->showState(); - break; - + } + break; /* cursor selection ---------------------------- */ case LFUN_RIGHTSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorLeft(bv_); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->CursorLeft(bv_); else - TEXT(bv_)->CursorRight(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorRight(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_LEFTSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorRight(bv_); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->CursorRight(bv_); else - TEXT(bv_)->CursorLeft(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorLeft(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_UPSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorUp(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorUp(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_DOWNSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorDown(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorDown(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_UP_PARAGRAPHSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorUpParagraph(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorUpParagraph(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_DOWN_PARAGRAPHSEL: - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorDownParagraph(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorDownParagraph(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_PRIORSEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - cursorPrevious(TEXT(bv_)); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + cursorPrevious(lt); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_NEXTSEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - cursorNext(TEXT(bv_)); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + cursorNext(lt); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_HOMESEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorHome(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->CursorHome(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_ENDSEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorEnd(bv_); - TEXT(bv_)->FinishUndo(); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->CursorEnd(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_WORDRIGHTSEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorLeftOneWord(bv_); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->CursorLeftOneWord(bv_); else - TEXT(bv_)->CursorRightOneWord(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorRightOneWord(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_WORDLEFTSEL: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params)) - TEXT(bv_)->CursorRightOneWord(bv_); + { + LyXText * lt = bv_->getLyXText(); + + update(lt, BufferView::SELECT|BufferView::FITCUR); + if (lt->cursor.par()->isRightToLeftPar(buffer_->params)) + lt->CursorRightOneWord(bv_); else - TEXT(bv_)->CursorLeftOneWord(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorLeftOneWord(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_BEGINNINGBUFSEL: - if (TEXT(bv_)->inset_owner) + { + LyXText * lt = bv_->getLyXText(); + + if (lt->inset_owner) break; - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorTop(bv_); - TEXT(bv_)->FinishUndo(); + update(lt, BufferView::SELECT|BufferView::FITCUR); + lt->CursorTop(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; case LFUN_ENDBUFSEL: - if (TEXT(bv_)->inset_owner) + { + LyXText * lt = bv_->getLyXText(); + + if (lt->inset_owner) break; - update(TEXT(bv_), + update(lt, BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->CursorBottom(bv_); - TEXT(bv_)->FinishUndo(); + lt->CursorBottom(bv_); + lt->FinishUndo(); moveCursorUpdate(true); owner_->showState(); - break; + } + break; // --- text changing commands ------------------------ case LFUN_BREAKLINE: - beforeChange(TEXT(bv_)); - TEXT(bv_)->InsertChar(bv_, LyXParagraph::META_NEWLINE); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + { + LyXText * lt = bv_->getLyXText(); + + beforeChange(lt); + lt->InsertChar(bv_, LyXParagraph::META_NEWLINE); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); moveCursorUpdate(false); - break; + } + break; case LFUN_PROTECTEDSPACE: { + LyXText * lt = bv_->getLyXText(); + LyXLayout const & style = textclasslist .Style(buffer_->params.textclass, - TEXT(bv_)->cursor.par()->GetLayout()); + lt->cursor.par()->GetLayout()); if (style.free_spacing) { - TEXT(bv_)->InsertChar(bv_, ' '); - update(TEXT(bv_), + lt->InsertChar(bv_, ' '); + update(lt, BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE); } else { - bv_->protectedBlank(TEXT(bv_)); + protectedBlank(lt); } moveCursorUpdate(false); } break; case LFUN_SETMARK: - if (TEXT(bv_)->mark_set) { - beforeChange(TEXT(bv_)); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR); + { + LyXText * lt = bv_->getLyXText(); + + if (lt->mark_set) { + beforeChange(lt); + update(lt, + BufferView::SELECT + | BufferView::FITCUR); owner_->getLyXFunc()->setMessage(N_("Mark removed")); } else { - beforeChange(TEXT(bv_)); - TEXT(bv_)->mark_set = 1; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR); + beforeChange(lt); + lt->mark_set = 1; + update(lt, + BufferView::SELECT + | BufferView::FITCUR); owner_->getLyXFunc()->setMessage(N_("Mark set")); } - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; - break; + lt->sel_cursor = lt->cursor; + } + break; case LFUN_DELETE: - if (!TEXT(bv_)->selection) { - TEXT(bv_)->Delete(bv_); - TEXT(bv_)->sel_cursor = - TEXT(bv_)->cursor; - update(TEXT(bv_), + { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection) { + lt->Delete(bv_); + lt->sel_cursor = lt->cursor; + update(lt, BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE); @@ -2157,22 +2331,25 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) moveCursorUpdate(false); owner_->showState(); setState(); - break; + } + break; case LFUN_DELETE_SKIP: { + LyXText * lt = bv_->getLyXText(); + // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP. - LyXCursor cursor = TEXT(bv_)->cursor; + LyXCursor cursor = lt->cursor; - if (!TEXT(bv_)->selection) { + if (!lt->selection) { if (cursor.pos() == cursor.par()->size()) { - TEXT(bv_)->CursorRight(bv_); - cursor = TEXT(bv_)->cursor; + lt->CursorRight(bv_); + cursor = lt->cursor; if (cursor.pos() == 0 && !(cursor.par()->params.spaceTop() == VSpace (VSpace::NONE))) { - TEXT(bv_)->SetParagraph + lt->SetParagraph (bv_, cursor.par()->params.lineTop(), cursor.par()->params.lineBottom(), @@ -2182,23 +2359,27 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) cursor.par()->params.spaceBottom(), cursor.par()->params.align(), cursor.par()->params.labelWidthString(), 0); - TEXT(bv_)->CursorLeft(bv_); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->CursorLeft(bv_); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } else { - TEXT(bv_)->CursorLeft(bv_); - TEXT(bv_)->Delete(bv_); - TEXT(bv_)->sel_cursor = - TEXT(bv_)->cursor; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->CursorLeft(bv_); + lt->Delete(bv_); + lt->sel_cursor = lt->cursor; + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } } else { - TEXT(bv_)->Delete(bv_); - TEXT(bv_)->sel_cursor = - TEXT(bv_)->cursor; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->Delete(bv_); + lt->sel_cursor = lt->cursor; + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } } else { bv_->cut(); @@ -2208,56 +2389,59 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) /* -------> Delete word forward. */ case LFUN_DELETE_WORD_FORWARD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->DeleteWordForward(bv_); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + bv_->getLyXText()->DeleteWordForward(bv_); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); moveCursorUpdate(false); owner_->showState(); break; /* -------> Delete word backward. */ case LFUN_DELETE_WORD_BACKWARD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->DeleteWordBackward(bv_); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + bv_->getLyXText()->DeleteWordBackward(bv_); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); moveCursorUpdate(false); owner_->showState(); break; /* -------> Kill to end of line. */ case LFUN_DELETE_LINE_FORWARD: - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->DeleteLineForward(bv_); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + bv_->getLyXText()->DeleteLineForward(bv_); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); moveCursorUpdate(false); break; /* -------> Set mark off. */ case LFUN_MARK_OFF: - beforeChange(TEXT(bv_)); - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; + beforeChange(bv_->getLyXText()); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + bv_->getLyXText()->sel_cursor = bv_->getLyXText()->cursor; owner_->getLyXFunc()->setMessage(N_("Mark off")); break; /* -------> Set mark on. */ case LFUN_MARK_ON: - beforeChange(TEXT(bv_)); - TEXT(bv_)->mark_set = 1; - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR); - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; + beforeChange(bv_->getLyXText()); + bv_->getLyXText()->mark_set = 1; + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + bv_->getLyXText()->sel_cursor = bv_->getLyXText()->cursor; owner_->getLyXFunc()->setMessage(N_("Mark on")); break; case LFUN_BACKSPACE: { - if (!TEXT(bv_)->selection) { + LyXText * lt = bv_->getLyXText(); + + if (!lt->selection) { if (owner_->getIntl()->getTrans().backspace()) { - TEXT(bv_)->Backspace(bv_); - TEXT(bv_)->sel_cursor = - TEXT(bv_)->cursor; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->Backspace(bv_); + lt->sel_cursor = lt->cursor; + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); // It is possible to make it a lot faster still // just comment out the line below... showCursor(); @@ -2273,14 +2457,15 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_BACKSPACE_SKIP: { // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP. + LyXText * lt = bv_->getLyXText(); - LyXCursor cursor = TEXT(bv_)->cursor; + LyXCursor cursor = lt->cursor; - if (!TEXT(bv_)->selection) { + if (!lt->selection) { if (cursor.pos() == 0 && !(cursor.par()->params.spaceTop() == VSpace (VSpace::NONE))) { - TEXT(bv_)->SetParagraph + lt->SetParagraph (bv_, cursor.par()->params.lineTop(), cursor.par()->params.lineBottom(), @@ -2289,14 +2474,17 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) VSpace(VSpace::NONE), cursor.par()->params.spaceBottom(), cursor.par()->params.align(), cursor.par()->params.labelWidthString(), 0); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } else { - TEXT(bv_)->Backspace(bv_); - TEXT(bv_)->sel_cursor - = cursor; - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->Backspace(bv_); + lt->sel_cursor = cursor; + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } } else bv_->cut(); @@ -2305,11 +2493,15 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_BREAKPARAGRAPH: { - beforeChange(TEXT(bv_)); - TEXT(bv_)->BreakParagraph(bv_, 0); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; + LyXText * lt = bv_->getLyXText(); + + beforeChange(lt); + lt->BreakParagraph(bv_, 0); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + lt->sel_cursor = lt->cursor; setState(); owner_->showState(); break; @@ -2317,11 +2509,15 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_BREAKPARAGRAPHKEEPLAYOUT: { - beforeChange(TEXT(bv_)); - TEXT(bv_)->BreakParagraph(bv_, 1); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; + LyXText * lt = bv_->getLyXText(); + + beforeChange(lt); + lt->BreakParagraph(bv_, 1); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + lt->sel_cursor = lt->cursor; setState(); owner_->showState(); break; @@ -2332,13 +2528,14 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) // When at the beginning of a paragraph, remove // indentation and add a "defskip" at the top. // Otherwise, do the same as LFUN_BREAKPARAGRAPH. + LyXText * lt = bv_->getLyXText(); - LyXCursor cursor = TEXT(bv_)->cursor; + LyXCursor cursor = lt->cursor; - beforeChange(TEXT(bv_)); + beforeChange(lt); if (cursor.pos() == 0) { if (cursor.par()->params.spaceTop() == VSpace(VSpace::NONE)) { - TEXT(bv_)->SetParagraph + lt->SetParagraph (bv_, cursor.par()->params.lineTop(), cursor.par()->params.lineBottom(), @@ -2351,13 +2548,15 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) } } else { - TEXT(bv_)->BreakParagraph(bv_, 0); + lt->BreakParagraph(bv_, 0); //update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); } - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - TEXT(bv_)->sel_cursor = cursor; + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + lt->sel_cursor = cursor; setState(); owner_->showState(); } @@ -2365,7 +2564,9 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_PARAGRAPH_SPACING: { - LyXParagraph * par = TEXT(bv_)->cursor.par(); + LyXText * lt = bv_->getLyXText(); + + LyXParagraph * par = lt->cursor.par(); Spacing::Space cur_spacing = par->params.spacing().getSpace(); float cur_value = 1.0; if (cur_spacing == Spacing::Other) { @@ -2402,22 +2603,17 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) } if (cur_spacing != new_spacing || cur_value != new_value) { par->params.spacing(Spacing(new_spacing, new_value)); - TEXT(bv_)->RedoParagraph(bv_); - update(TEXT(bv_), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + lt->RedoParagraph(bv_); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); } } break; case LFUN_QUOTE: -#if 0 - beforeChange(TEXT(bv_)); - TEXT(bv_)->InsertChar(bv_, '\"'); // This " matches the single quote in the code - update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - moveCursorUpdate(false); -#else bv_->insertCorrectQuote(); -#endif break; case LFUN_HTMLURL: @@ -2569,7 +2765,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) InsetTabular * new_inset = new InsetTabular(*buffer_, r, c); bool rtl = - TEXT(bv_)->real_current_font.isRightToLeft(); + bv_->getLyXText()->real_current_font.isRightToLeft(); if (!open_new_inset(new_inset, rtl)) delete new_inset; } @@ -2579,19 +2775,19 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_CHARATCURSOR: { - LyXParagraph::size_type pos = TEXT(bv_)->cursor.pos(); - if (pos < TEXT(bv_)->cursor.par()->size()) + LyXParagraph::size_type pos = bv_->getLyXText()->cursor.pos(); + if (pos < bv_->getLyXText()->cursor.par()->size()) owner_->getLyXFunc()->setMessage( - tostr(TEXT(bv_)->cursor.par()->GetChar(pos))); + tostr(bv_->getLyXText()->cursor.par()->GetChar(pos))); else owner_->getLyXFunc()->setMessage("EOF"); } break; case LFUN_GETXY: - owner_->getLyXFunc()->setMessage(tostr(TEXT(bv_)->cursor.x()) + owner_->getLyXFunc()->setMessage(tostr(bv_->getLyXText()->cursor.x()) + ' ' - + tostr(TEXT(bv_)->cursor.y())); + + tostr(bv_->getLyXText()->cursor.y())); break; case LFUN_SETXY: @@ -2599,17 +2795,17 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) int x; int y; ::sscanf(argument.c_str(), " %d %d", &x, &y); - TEXT(bv_)->SetCursorFromCoordinates(bv_, x, y); + bv_->getLyXText()->SetCursorFromCoordinates(bv_, x, y); } break; case LFUN_GETLAYOUT: - owner_->getLyXFunc()->setMessage(tostr(TEXT(bv_)->cursor.par()->layout)); + owner_->getLyXFunc()->setMessage(tostr(bv_->getLyXText()->cursor.par()->layout)); break; case LFUN_GETFONT: { - LyXFont & font = TEXT(bv_)->current_font; + LyXFont & font = bv_->getLyXText()->current_font; if (font.shape() == LyXFont::ITALIC_SHAPE) owner_->getLyXFunc()->setMessage("E"); else if (font.shape() == LyXFont::SMALLCAPS_SHAPE) @@ -2622,7 +2818,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_GETLATEX: { - LyXFont & font = TEXT(bv_)->current_font; + LyXFont & font = bv_->getLyXText()->current_font; if (font.latex() == LyXFont::ON) owner_->getLyXFunc()->setMessage("L"); else @@ -2655,8 +2851,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) } else { owner_->getLyXFunc()->handleKeyFunc(action); owner_->getIntl()->getTrans() - .TranslateAndInsert(argument[0], TEXT(bv_)); - update(TEXT(bv_), + .TranslateAndInsert(argument[0], bv_->getLyXText()); + update(bv_->getLyXText(), BufferView::SELECT | BufferView::FITCUR | BufferView::CHANGE); @@ -2790,11 +2986,11 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (argument.empty()) { // Get the word immediately preceding the cursor LyXParagraph::size_type curpos = - TEXT(bv_)->cursor.pos() - 1; + bv_->getLyXText()->cursor.pos() - 1; string curstring; if (curpos >= 0 ) - curstring = TEXT(bv_) + curstring = bv_->getLyXText() ->cursor.par()->GetWord(curpos); p.setContents( curstring ); @@ -2823,11 +3019,11 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) { // Get word immediately preceding the cursor LyXParagraph::size_type curpos = - TEXT(bv_)->cursor.pos() - 1; + bv_->getLyXText()->cursor.pos() - 1; // Can't do that at the beginning of a paragraph if (curpos < 0) break; - string const curstring(TEXT(bv_) + string const curstring(bv_->getLyXText() ->cursor.par()->GetWord(curpos)); InsetCommandParams p("index", curstring); @@ -2891,28 +3087,6 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) case LFUN_SELFINSERT: { -#if 0 - LyXText * lt = TEXT(bv_); - - LyXFont const old_font(lt->real_current_font); - - string::const_iterator cit = argument.begin(); - string::const_iterator end = argument.end(); - for (; cit != end; ++cit) { - lt->InsertChar(bv_, *cit); - // This needs to be in the loop, or else we - // won't break lines correctly. (Asger) - update(lt, - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - } - lt->sel_cursor = lt->cursor; - moveCursorUpdate(false); - - // real_current_font.number can change so we need to - // update the minibuffer - if (old_font != lt->real_current_font) - owner_->showState(); -#else if (argument.empty()) break; /* Automatically delete the currently selected @@ -2921,7 +3095,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) * "auto_region_delete", which defaults to * true (on). */ - LyXText * lt = TEXT(bv_); + LyXText * lt = bv_->getLyXText(); if (lyxrc.auto_region_delete) { if (lt->selection){ @@ -2959,7 +3133,6 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) if (old_font != lt->real_current_font) owner_->showState(); //return string(); -#endif } break; @@ -2977,12 +3150,12 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) int const datetmp_len = ::strftime(datetmp, 32, arg.c_str(), now_tm); for (int i = 0; i < datetmp_len; i++) { - TEXT(bv_)->InsertChar(bv_, datetmp[i]); - update(TEXT(bv_), + bv_->getLyXText()->InsertChar(bv_, datetmp[i]); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); } - TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor; + bv_->getLyXText()->sel_cursor = bv_->getLyXText()->cursor; moveCursorUpdate(false); } break; @@ -2999,6 +3172,105 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument) } +void BufferView::Pimpl::newline() +{ + if (available()) { + LyXText * lt = bv_->getLyXText(); + hideCursor(); + update(lt, + BufferView::SELECT + | BufferView::FITCUR); + lt->InsertChar(bv_, LyXParagraph::META_NEWLINE); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } +} + + +void BufferView::Pimpl::hfill() +{ + if (available()) { + LyXText * lt = bv_->getLyXText(); + hideCursor(); + update(lt, + BufferView::SELECT + | BufferView::FITCUR); + lt->InsertChar(bv_, LyXParagraph::META_HFILL); + update(lt, + BufferView::SELECT + | BufferView::FITCUR + | BufferView::CHANGE); + } +} + + +void BufferView::Pimpl::protectedBlank(LyXText * lt) +{ + if (available()) { + hideCursor(); + update(lt, BufferView::SELECT|BufferView::FITCUR); + InsetSpecialChar * new_inset = + new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); + if (!bv_->insertInset(new_inset)) + delete new_inset; + else + bv_->updateInset(new_inset, true); + } +} + + +void BufferView::Pimpl::menuSeparator() +{ + if (available()) { + LyXText * lt = bv_->getLyXText(); + + hideCursor(); + update(lt, BufferView::SELECT|BufferView::FITCUR); + InsetSpecialChar * new_inset = + new InsetSpecialChar(InsetSpecialChar::MENU_SEPARATOR); + bv_->insertInset(new_inset); + } +} + + +void BufferView::Pimpl::endOfSentenceDot() +{ + if (available()) { + hideCursor(); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + InsetSpecialChar * new_inset = + new InsetSpecialChar(InsetSpecialChar::END_OF_SENTENCE); + bv_->insertInset(new_inset); + } +} + + +void BufferView::Pimpl::ldots() +{ + if (available()) { + hideCursor(); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + InsetSpecialChar * new_inset = + new InsetSpecialChar(InsetSpecialChar::LDOTS); + bv_->insertInset(new_inset); + } +} + + +void BufferView::Pimpl::hyphenationPoint() +{ + if (available()) { + hideCursor(); + update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR); + InsetSpecialChar * new_inset = + new InsetSpecialChar(InsetSpecialChar::HYPHENATION); + bv_->insertInset(new_inset); + } +} + + void BufferView::Pimpl::insertNote() { InsetInfo * new_inset = new InsetInfo(); @@ -3010,17 +3282,18 @@ void BufferView::Pimpl::insertNote() // Open and lock an updatable inset bool BufferView::Pimpl::open_new_inset(UpdatableInset * new_inset, bool behind) { - beforeChange(TEXT(bv_)); - TEXT(bv_)->FinishUndo(); + LyXText * lt = bv_->getLyXText(); + + beforeChange(lt); + lt->FinishUndo(); if (!bv_->insertInset(new_inset)) { delete new_inset; return false; } if (behind) { - LyXFont & font = bv_->getLyXText()->real_current_font; + LyXFont & font = lt->real_current_font; new_inset->Edit(bv_, new_inset->width(bv_, font), 0, 0); } else new_inset->Edit(bv_, 0, 0, 0); return true; } - diff --git a/src/BufferView_pimpl.h b/src/BufferView_pimpl.h index 41afe0b1de..59a2cba5f7 100644 --- a/src/BufferView_pimpl.h +++ b/src/BufferView_pimpl.h @@ -125,6 +125,20 @@ private: /// open and lock an updatable inset bool open_new_inset(UpdatableInset * new_inset, bool behind = false); /// + void protectedBlank(LyXText * lt); + /// + void newline(); + /// + void hfill(); + /// + void menuSeparator(); + /// + void endOfSentenceDot(); + /// + void ldots(); + /// + void hyphenationPoint(); + /// void insertNote(); /// BufferView * bv_; diff --git a/src/ChangeLog b/src/ChangeLog index affd70d3d0..1a2645d085 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,15 @@ +2001-05-29 Lars Gullik Bjønnes + + * lyx_main.C (defaultKeyBindings): move self-insert KP_ bindings + to latinkeys.bind. + + * lyxfunc.C (processKeySym): change method of getting to the + self-insert char. + + * BufferView(2).[Ch]: move hfill, protectedBlank, newline, + menuSeparator, endOfSentenceDot, ldots, hypenationPoint and menuUndo + * BufferView_pimpl.[Ch]: here as private methods. + 2001-05-28 Juergen Vigna * text.C (SetHeightOfRow): added the update() call again as it is diff --git a/src/insets/insetspecialchar.C b/src/insets/insetspecialchar.C index 9f40477967..22649f50c9 100644 --- a/src/insets/insetspecialchar.C +++ b/src/insets/insetspecialchar.C @@ -165,7 +165,7 @@ void InsetSpecialChar::Write(Buffer const *, ostream & os) const void InsetSpecialChar::Read(Buffer const *, LyXLex & lex) { lex.nextToken(); - string command = lex.GetString(); + string const command = lex.GetString(); if (command == "\\-") kind = HYPHENATION; diff --git a/src/lyx_main.C b/src/lyx_main.C index 259ad5c5b5..7c1ef189a8 100644 --- a/src/lyx_main.C +++ b/src/lyx_main.C @@ -464,34 +464,29 @@ void LyX::defaultKeyBindings(kb_keymap * kbmap) kbmap->bind("Next", LFUN_NEXT); kbmap->bind("Return", LFUN_BREAKPARAGRAPH); - kbmap->bind("~C-~S-~M-nobreakspace", LFUN_PROTECTEDSPACE); + //kbmap->bind("~C-~S-~M-nobreakspace", LFUN_PROTECTEDSPACE); kbmap->bind("Delete", LFUN_DELETE); kbmap->bind("BackSpace", LFUN_BACKSPACE); // kbmap->bindings to enable the use of the numeric keypad // e.g. Num Lock set - kbmap->bind("KP_0", LFUN_SELFINSERT); - kbmap->bind("KP_Decimal", LFUN_SELFINSERT); + //kbmap->bind("KP_0", LFUN_SELFINSERT); + //kbmap->bind("KP_Decimal", LFUN_SELFINSERT); kbmap->bind("KP_Enter", LFUN_BREAKPARAGRAPH); - kbmap->bind("KP_1", LFUN_SELFINSERT); - kbmap->bind("KP_2", LFUN_SELFINSERT); - kbmap->bind("KP_3", LFUN_SELFINSERT); - kbmap->bind("KP_4", LFUN_SELFINSERT); - kbmap->bind("KP_5", LFUN_SELFINSERT); - kbmap->bind("KP_6", LFUN_SELFINSERT); - kbmap->bind("KP_Add", LFUN_SELFINSERT); - kbmap->bind("KP_7", LFUN_SELFINSERT); - kbmap->bind("KP_8", LFUN_SELFINSERT); - kbmap->bind("KP_9", LFUN_SELFINSERT); - kbmap->bind("KP_Divide", LFUN_SELFINSERT); - kbmap->bind("KP_Multiply", LFUN_SELFINSERT); - kbmap->bind("KP_Subtract", LFUN_SELFINSERT); - - /* Most self-insert keys are handled in the 'default:' section of - * WorkAreaKeyPress - so we don't have to define them all. - * However keys explicit decleared as self-insert are - * handled seperatly (LFUN_SELFINSERT.) Lgb. */ + //kbmap->bind("KP_1", LFUN_SELFINSERT); + //kbmap->bind("KP_2", LFUN_SELFINSERT); + //kbmap->bind("KP_3", LFUN_SELFINSERT); + //kbmap->bind("KP_4", LFUN_SELFINSERT); + //kbmap->bind("KP_5", LFUN_SELFINSERT); + //kbmap->bind("KP_6", LFUN_SELFINSERT); + //kbmap->bind("KP_Add", LFUN_SELFINSERT); + //kbmap->bind("KP_7", LFUN_SELFINSERT); + //kbmap->bind("KP_8", LFUN_SELFINSERT); + //kbmap->bind("KP_9", LFUN_SELFINSERT); + //kbmap->bind("KP_Divide", LFUN_SELFINSERT); + //kbmap->bind("KP_Multiply", LFUN_SELFINSERT); + //kbmap->bind("KP_Subtract", LFUN_SELFINSERT); kbmap->bind("C-Tab", LFUN_TABINSERT); // ale970515 kbmap->bind("S-Tab", LFUN_SHIFT_TAB); // jug20000522 diff --git a/src/lyxfunc.C b/src/lyxfunc.C index d40c5a4a22..ac26544660 100644 --- a/src/lyxfunc.C +++ b/src/lyxfunc.C @@ -237,31 +237,6 @@ void LyXFunc::processKeySym(KeySym keysym, unsigned int state) return; } -#if 0 - // This if clause should not be here, but should rather be changed - // to a lyxfunc and get XK_Escape bound to it (Lgb) -#warning Fix this please. (Lgb) - if (owner->view()->available()) { - // this function should be used always [asierra060396] - UpdatableInset * tli = owner->view()->theLockingInset(); - if (tli && (keysym == XK_Escape)) { - if (tli == tli->GetLockingInset()) { - owner->view()->unlockInset(tli); - TEXT()->CursorRight(owner->view()); - moveCursorUpdate(true, false); - owner->showState(); - } else { - tli->UnlockInsetInInset(owner->view(), - tli->GetLockingInset(), - true); - } - //return 0; - //return FL_PREEMPT; - return; - } - } -#endif - // Can we be sure that this will work for all X-Windows // implementations? (Lgb) // This code snippet makes lyx ignore some keys. Perhaps @@ -309,7 +284,7 @@ void LyXFunc::processKeySym(KeySym keysym, unsigned int state) if (lyxerr.debugging(Debug::KEY)) { string buf; keyseq.print(buf); - lyxerr << "Key [" + lyxerr << "Key [action=" << action << "][" << buf << "]" << endl; @@ -330,10 +305,6 @@ void LyXFunc::processKeySym(KeySym keysym, unsigned int state) // the modifiers? (Lgb) action = keyseq.addkey(keysym, 0); - // We keep the shift state, but remove the others. - // This is for the sake of the LFUN_SELFINSERT below. - state &= ShiftMask; - if (lyxerr.debugging(Debug::KEY)) { lyxerr << "Removing modifiers...\n" << "Action now set to [" @@ -347,39 +318,34 @@ void LyXFunc::processKeySym(KeySym keysym, unsigned int state) } if (action == LFUN_SELFINSERT) { - // We must set the argument to the char looked up by - // XKeysymToString - XKeyEvent xke; - xke.type = KeyPress; - xke.serial = 0; - xke.send_event = False; - xke.display = fl_get_display(); - xke.window = 0; - xke.root = 0; - xke.subwindow = 0; - xke.time = 0; - xke.x = 0; - xke.y = 0; - xke.x_root = 0; - xke.y_root = 0; - xke.state = state; - xke.keycode = XKeysymToKeycode(fl_get_display(), keysym); - xke.same_screen = True; - char ret[10]; - KeySym tmpkeysym; - int const res = XLookupString(&xke, ret, 10, &tmpkeysym, 0); - //Assert(keysym == tmpkeysym); - lyxerr[Debug::KEY] << "TmpKeysym [" - << tmpkeysym << "]" << endl; + // This is very X dependant. + unsigned int c = keysym; - if (res > 0) - argument = string(ret, res); - - lyxerr[Debug::KEY] << "SelfInsert arg[" - << argument << "]" << endl; + switch (c & 0x0000FF00) { + // latin 1 byte 3 = 0 + case 0x00000000: break; + // latin 2 byte 3 = 1 + case 0x00000100: + // latin 3 byte 3 = 2 + case 0x00000200: + // latin 4 byte 3 = 3 + case 0x00000300: + // latin 8 byte 3 = 18 (0x12) + case 0x00001200: + // latin 9 byte 3 = 19 (0x13) + case 0x00001300: + c &= 0x000000FF; + break; + default: + c = 0; + break; + } + if (c > 0) + argument = static_cast(c); + lyxerr[Debug::KEY] << "SelfInsert arg[`" + << argument << "']" << endl; } - bool tmp_sc = show_sc; show_sc = false; Dispatch(action, argument); @@ -1004,27 +970,7 @@ string const LyXFunc::Dispatch(int ac, owner->view()->fitCursor(TEXT()); } break; - - case LFUN_HYPHENATION: - owner->view()->hyphenationPoint(); - break; - - case LFUN_LDOTS: - owner->view()->ldots(); - break; - - case LFUN_END_OF_SENTENCE: - owner->view()->endOfSentenceDot(); - break; - case LFUN_MENU_SEPARATOR: - owner->view()->menuSeparator(); - break; - - case LFUN_HFILL: - owner->view()->hfill(); - break; - case LFUN_DEPTH: changeDepth(owner->view(), TEXT(false), 0); break; diff --git a/src/support/ChangeLog b/src/support/ChangeLog index c86e5a6e5e..a94949fb44 100644 --- a/src/support/ChangeLog +++ b/src/support/ChangeLog @@ -1,3 +1,11 @@ +2001-05-29 Lars Gullik Bjønnes + + * lyxsum.C (sum): don't use sstream anymore, use istream_iterator + directly instead. + + * lyxstring.C (operator): make const operator[] behave as + non-const and at. + 2001-05-22 Jean-Marc Lasgouttes * Makefile.am (EXTRA_DIST): add the os_*.C files. diff --git a/src/support/lyxstring.C b/src/support/lyxstring.C index e8fb486c3c..cc25a90a9f 100644 --- a/src/support/lyxstring.C +++ b/src/support/lyxstring.C @@ -658,9 +658,14 @@ lyxstring & lyxstring::assign(const_iterator first, const_iterator last) lyxstring::const_reference lyxstring::operator[](size_type pos) const { +#if 0 lyx::Assert(pos <= rep->sz); // OURS! static char helper = '\0'; return pos == rep->sz ? helper : rep->s[pos]; +#else + lyx::Assert(pos < rep->sz); // OURS! + return rep->s[pos]; +#endif } diff --git a/src/support/lyxsum.C b/src/support/lyxsum.C index c74cbafe39..0f8304d11d 100644 --- a/src/support/lyxsum.C +++ b/src/support/lyxsum.C @@ -4,7 +4,7 @@ * LyX, The Document Processor * * The function lyx::sum is taken from GNU textutill-1.22 - * and is there part of the program chsum. The chsum program + * and is there part of the program chsum. The cksum program * is written by Q. Frank Xia, qx@math.columbia.edu. * * Modified for use in LyX by Lars G. Bjønnes. @@ -16,13 +16,13 @@ #include #include - -#include "Lsstream.h" +#include #include "support/lyxlib.h" using std::ifstream; using std::ios; +using std::istream_iterator; namespace { @@ -92,7 +92,7 @@ unsigned long do_crc(InputIterator first, InputIterator last) { unsigned long crc = 0; long bytes_read = 0; - while(first != last) { + while (first != last) { ++bytes_read; crc = (crc << 8) ^ crctab[((crc >> 24) ^ *first++) & 0xFF]; @@ -114,11 +114,7 @@ unsigned long lyx::sum(string const & file) ifstream ifs(file.c_str()); if (!ifs) return 0; ifs.unsetf(ios::skipws); - ostringstream ostr; - ostr << ifs.rdbuf(); - // The .c_str() is here in case we use our lyxstring class - // instead of standard string. - string w = ostr.str().c_str(); - return do_crc(w.begin(), w.end()); + istream_iterator beg(ifs); + istream_iterator end; + return do_crc(beg, end); } - -- 2.39.5