// 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)
#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
// 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]
// BOOST_NO_STD_MIN_MAX: The C++ standard library does not provide
// the min() and max() template functions that should be in <algorithm>.
+// 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++) --------------------------------------//
// egcs 1.1 won't parse smart_ptr.hpp without this:
# define BOOST_NO_AUTO_PTR
# endif
-# if __GNUC__ == 2 && __GNUC_MINOR__ <= 95
-# include <iterator> // 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 <string> // 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
# 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 <iterator>
# if defined(__GLIBCPP__)
# endif
# endif
-// Kai C++ ------------------------------------------------------------------//
+// Intel on Linux ---------------------------------------------------------
+
+#elif defined __ICC
+# include <iterator>
+# 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
#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++ -----------------------------------------------------------//
#elif defined __BORLANDC__
# define BOOST_NO_SLIST
# define BOOST_NO_HASH
+// pull in standard library version:
+# include <memory>
# if __BORLANDC__ <= 0x0551
# define BOOST_NO_INTEGRAL_INT64_T
# define BOOST_NO_PRIVATE_IN_AGGREGATE
# else
# define BOOST_DECL
# endif
+#if (__BORLANDC__ == 0x550) || (__BORLANDC__ == 0x551)
+// <climits> 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 <float.h>
+#endif
+# define BOOST_NO_CV_SPECIALIZATIONS
+# define BOOST_NO_CV_VOID_SPECIALIZATIONS
-// Intel -------------------------------------------------------------------//
+// Intel on Windows --------------------------------------------------------//
# elif defined __ICL
# include <iterator> // not sure this is the right way to do this -JGS
// 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
# 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
# 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
// 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
# 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
// 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
}
#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
+
+
+
+
+
#include "insets/insettheorem.h"
#include "insets/insetcaption.h"
#include "insets/insetfloatlist.h"
+#include "insets/insetspecialchar.h"
#include "mathed/formulamacro.h"
#include "gettext.h"
* 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. */
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()),
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;
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:
{
}
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:
}
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();
}
}
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:
// --- 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();
}
{
// 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_,
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);
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(),
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();
/* -------> 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();
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(),
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();
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;
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;
// 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(),
}
}
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();
}
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) {
}
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:
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;
}
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:
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)
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
} 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);
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 );
{
// 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);
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
* "auto_region_delete", which defaults to
* true (on). */
- LyXText * lt = TEXT(bv_);
+ LyXText * lt = bv_->getLyXText();
if (lyxrc.auto_region_delete) {
if (lt->selection){
if (old_font != lt->real_current_font)
owner_->showState();
//return string();
-#endif
}
break;
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;
}
+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();
// 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;
}
-
projects / features.git / commitdiff