// -*- C++ -*-
/**
- * File: math_cursor.h
- * Purpose: Declaration of interaction classes for mathed
- * Author: Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
- * Created: January 1996
- * Description: MathCursor control all user interaction
+ * \file math_cursor.h
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * Dependencies: Xlib, XForms
+ * \author Alejandro Aguilar Sierra
+ * \author André Pönitz
*
- * Copyright: 1996, Alejandro Aguilar Sierra
- *
- * You are free to use and modify this code under the terms of
- * the GNU General Public Licence version 2 or later.
+ * Full author contact details are available in file CREDITS.
*/
#ifndef MATH_CURSOR
#define MATH_CURSOR
-
+#include "cursor_slice.h"
#include "math_inset.h"
-#include "math_iterator.h"
-#include "LString.h"
+#include "math_data.h"
+
+#include <string>
class InsetFormulaBase;
class BufferView;
[Have a look at math_inset.h first]
The MathCursor is different from the kind of cursor used in the Outer
-World. It contains a stack of MathCursorPos, each of which is made
+World. It contains a stack of CursorSlice, each of which is made
up of a inset pointer, an index and a position offset, marking a path from
this formula's MathHullInset to the current position.
class MathCursor {
public:
/// short of anything else reasonable
- typedef MathInset::size_type size_type;
+ typedef size_t size_type;
/// type for column numbers
- typedef MathArray::difference_type difference_type;
+ typedef ptrdiff_t difference_type;
/// type for cursor positions within a cell
- typedef MathInset::pos_type pos_type;
+ typedef lyx::pos_type pos_type;
/// type for cell indices
- typedef MathInset::idx_type idx_type;
+ typedef size_t idx_type;
/// type for row numbers
- typedef MathInset::row_type row_type;
+ typedef size_t row_type;
/// type for column numbers
- typedef MathInset::col_type col_type;
+ typedef size_t col_type;
///
- explicit MathCursor(InsetFormulaBase *, bool left);
+ explicit MathCursor(BufferView *, InsetFormulaBase *, bool left);
///
~MathCursor();
///
- void insert(MathAtom const &);
+ void insert(BufferView & bv, MathAtom const &);
///
- void insert(MathArray const &);
+ void insert(BufferView & bv, MathArray const &);
///
- void paste(string const & data);
+ void insert2(BufferView & bv, std::string const &);
+ ///
+ void paste(BufferView & bv, std::string const & data);
/// return false for empty math insets
- bool erase();
+ bool erase(BufferView & bv);
/// return false for empty math insets
- bool backspace();
+ bool backspace(BufferView & bv);
/// called for LFUN_HOME etc
- bool home(bool sel = false);
+ bool home(BufferView & bv, bool sel = false);
/// called for LFUN_END etc
- bool end(bool sel = false);
+ bool end(BufferView & bv, bool sel = false);
/// called for LFUN_RIGHT and LFUN_RIGHTSEL
- bool right(bool sel = false);
+ bool right(BufferView & bv, bool sel = false);
/// called for LFUN_LEFT etc
- bool left(bool sel = false);
+ bool left(BufferView & bv, bool sel = false);
/// called for LFUN_UP etc
- bool up(bool sel = false);
+ bool up(BufferView & bv, bool sel = false);
/// called for LFUN_DOWN etc
- bool down(bool sel = false);
+ bool down(BufferView & bv, bool sel = false);
/// Put the cursor in the first position
- void first();
+ void first(BufferView & bv);
/// Put the cursor in the last position
- void last();
+ void last(BufferView & bv);
/// move to next cell in current inset
- void idxNext();
+ void idxNext(BufferView & bv);
/// move to previous cell in current inset
- void idxPrev();
+ void idxPrev(BufferView & bv);
///
- void plainErase();
+ void plainErase(BufferView & bv);
///
- void plainInsert(MathAtom const &);
+ void plainInsert(BufferView & bv, MathAtom const & at);
///
- void niceInsert(MathAtom const &);
+ void niceInsert(BufferView & bv, MathAtom const & at);
///
- void niceInsert(string const &);
+ void niceInsert(BufferView & bv, std::string const & str);
/// in pixels from top of screen
- void setPos(int x, int y);
+ void setScreenPos(BufferView & bv, int x, int y);
/// in pixels from top of screen
- void getPos(int & x, int & y) const;
+ void getScreenPos(BufferView & bv, int & x, int & y) const;
/// in pixels from left of screen
- int targetX() const;
- /// current inset
- MathInset * par() const;
+ int targetX(BufferView & bv) const;
/// return the next enclosing grid inset and the cursor's index in it
- MathGridInset * enclosingGrid(idx_type & idx) const;
+ MathGridInset * enclosingGrid(BufferView & bv, idx_type & idx) const;
/// go up to enclosing grid
- void popToEnclosingGrid();
+ void popToEnclosingGrid(BufferView & bv);
/// go up to the hull inset
- void popToEnclosingHull();
+ void popToEnclosingHull(BufferView & bv);
/// go up to the hull inset
- void popToHere(MathInset const * p);
+ void popToHere(BufferView & bv, MathInset const * p);
/// adjust anchor position after deletions/insertions
- void adjust(pos_type from, difference_type diff);
+ void adjust(BufferView & bv, pos_type from, difference_type diff);
///
InsetFormulaBase * formula() const;
/// current offset in the current cell
- pos_type pos() const;
- /// current cell
- idx_type idx() const;
- /// size of current cell
- size_type size() const;
///
- bool script(bool);
+ bool script(BufferView & bv, bool);
///
- bool interpret(char);
+ bool interpret(BufferView & bv, char);
/// interpret name a name of a macro
- void macroModeClose();
+ void macroModeClose(BufferView & bv);
/// are we currently typing the name of a macro?
- bool inMacroMode() const;
+ bool inMacroMode(BufferView & bv) const;
/// get access to the macro we are currently typing
- MathUnknownInset * activeMacro();
+ MathUnknownInset * activeMacro(BufferView & bv);
/// get access to the macro we are currently typing
- MathUnknownInset const * activeMacro() const;
+ MathUnknownInset const * activeMacro(BufferView & bv) const;
/// are we currently typing '#1' or '#2' or...?
- bool inMacroArgMode() const;
+ bool inMacroArgMode(BufferView & bv) const;
/// are we in math mode (1), text mode (-1) or unsure?
- MathInset::mode_type currentMode() const;
+ MathInset::mode_type currentMode(BufferView & bv) const;
// Local selection methods
///
bool selection() const;
///
- void selCopy();
+ void selCopy(BufferView & bv);
///
- void selCut();
+ void selCut(BufferView & bv);
///
- void selDel();
+ void selDel(BufferView & bv);
/// pastes n-th element of cut buffer
- void selPaste(int n);
+ void selPaste(BufferView & bv, size_t n);
///
- void selHandle(bool);
+ void selHandle(BufferView & bv, bool);
///
- void selStart();
+ void selStart(BufferView & bv);
///
- void selClear();
+ void selClear(BufferView & bv);
/// clears or deletes selection depending on lyxrc setting
- void selClearOrDel();
+ void selClearOrDel(BufferView & bv);
/// draws light-blue selection background
void drawSelection(PainterInfo & pi) const;
- ///
- void handleNest(MathAtom const & at);
+ /// replace selected stuff with at, placing the former
+ // selection in given cell of atom
+ void handleNest(BufferView & bv, MathAtom const & at, int cell = 0);
/// remove this as soon as LyXFunc::getStatus is "localized"
- string getLastCode() const { return "mathnormal"; }
+ std::string getLastCode() const { return "mathnormal"; }
///
bool isInside(MathInset const *) const;
///
- char valign() const;
+ char valign(BufferView & bv) const;
///
- char halign() const;
+ char halign(BufferView & bv) const;
/// make sure cursor position is valid
- void normalize();
+ void normalize(BufferView & bv);
/// mark current cursor trace for redraw
void touch();
- ///
- UpdatableInset * asHyperActiveInset() const;
/// enter a MathInset
- void push(MathAtom & par);
+ void push(BufferView & bv, MathAtom & par);
/// enter a MathInset from the front
- void pushLeft(MathAtom & par);
+ void pushLeft(BufferView & bv, MathAtom & par);
/// enter a MathInset from the back
- void pushRight(MathAtom & par);
+ void pushRight(BufferView & bv, MathAtom & par);
/// leave current MathInset to the left
- bool popLeft();
+ bool popLeft(BufferView & bv);
/// leave current MathInset to the left
- bool popRight();
+ bool popRight(BufferView & bv);
///
- MathArray & array() const;
- ///
- bool hasPrevAtom() const;
+ bool hasPrevAtom(BufferView & bv) const;
///
- bool hasNextAtom() const;
+ bool hasNextAtom(BufferView & bv) const;
///
- MathAtom const & prevAtom() const;
+ MathAtom const & prevAtom(BufferView & bv) const;
///
- MathAtom & prevAtom();
+ MathAtom & prevAtom(BufferView & bv);
///
- MathAtom const & nextAtom() const;
+ MathAtom const & nextAtom(BufferView & bv) const;
///
- MathAtom & nextAtom();
+ MathAtom & nextAtom(BufferView & bv);
/// returns the selection
- void getSelection(MathCursorPos &, MathCursorPos &) const;
+ void getSelection(BufferView & bv, CursorSlice &, CursorSlice &) const;
/// returns the normalized anchor of the selection
- MathCursorPos normalAnchor() const;
+ CursorSlice normalAnchor(BufferView & bv) const;
- /// reference to the last item of the path, i.e. "The Cursor"
- MathCursorPos & cursor();
- /// reference to the last item of the path, i.e. "The Cursor"
- MathCursorPos const & cursor() const;
/// how deep are we nested?
- unsigned depth() const;
-
- /// local dispatcher
- dispatch_result dispatch(FuncRequest const & cmd);
+ unsigned depth(BufferView & bv) const;
/// describe the situation
- string info() const;
+ std::string info(BufferView & bv) const;
/// dump selection information for debugging
void seldump(char const * str) const;
/// dump selection information for debugging
void dump(char const * str) const;
/// moves on
- void setSelection(MathIterator const & where, size_type n);
+ void setSelection(BufferView & bv, CursorBase const & where, size_type n);
/// grab selection marked by anchor and current cursor
- string grabSelection() const;
+ std::string grabSelection(BufferView & bv) const;
/// guess what
- string grabAndEraseSelection();
+ std::string grabAndEraseSelection(BufferView & bv);
///
- void insert(char c);
+ void insert(BufferView & bv, char c);
///
- void insert(string const & str);
+ void insert(BufferView & bv, std::string const & str);
/// lock/unlock inset
- void insetToggle();
+ void insetToggle(BufferView & bv);
/// hack for reveal codes
- void markInsert();
- void markErase();
+ void markInsert(BufferView & bv);
+ void markErase(BufferView & bv);
/// injects content of a cell into parent
- void pullArg();
+ void pullArg(BufferView & bv);
/// split font inset etc
- void handleFont(string const & font);
-
+ void handleFont(BufferView & bv, std::string const & font);
+ ///
+ DispatchResult dispatch(BufferView & bv, FuncRequest const & cmd);
private:
/// moves cursor index one cell to the left
- bool idxLeft();
+ bool idxLeft(BufferView & bv);
/// moves cursor index one cell to the right
- bool idxRight();
+ bool idxRight(BufferView & bv);
/// moves cursor to end of last cell of current line
- bool idxLineLast();
+ bool idxLineLast(BufferView & bv);
/// moves cursor position one cell to the left
- bool posLeft();
+ bool posLeft(BufferView & bv);
/// moves cursor position one cell to the right
- bool posRight();
+ bool posRight(BufferView & bv);
/// moves position somehow up or down
- bool goUpDown(bool up);
+ bool goUpDown(BufferView & bv, bool up);
/// moves position closest to (x, y) in given box
- bool bruteFind(int x, int y, int xlow, int xhigh, int ylow, int yhigh);
+ bool bruteFind(BufferView & bv,
+ int x, int y, int xlow, int xhigh, int ylow, int yhigh);
/// moves position closest to (x, y) in current cell
- void bruteFind2(int x, int y);
+ void bruteFind2(BufferView & bv, int x, int y);
/// are we in a nucleus of a script inset?
- bool inNucleus() const;
+ bool inNucleus(BufferView & bv) const;
/// erase the selected part and re-sets the cursor
- void eraseSelection();
+ void eraseSelection(BufferView & bv);
/// the name of the macro we are currently inputting
- string macroName() const;
+ std::string macroName(BufferView & bv) const;
/// where in the curent cell does the macro name start?
- difference_type macroNamePos() const;
+ difference_type macroNamePos(BufferView & bv) const;
/// can we enter the inset?
bool openable(MathAtom const &, bool selection) const;
- /// write access to cursor cell position
- pos_type & pos();
- /// write access to cursor cell index
- idx_type & idx();
- /// path of positions the cursor had to go if it were leaving each inset
- MathIterator Cursor_;
- /// path of positions the anchor had to go if it were leaving each inset
- mutable MathIterator Anchor_;
/// pointer to enclsing LyX inset
InsetFormulaBase * formula_;
// Selection stuff
bool selection_;
/// are we entering a macro name?
bool macromode_;
- /// are we targeting a certain x coordinate, if so, which one?
- int targetx_;
};
extern MathCursor * mathcursor;
-void releaseMathCursor(BufferView * bv);
+void releaseMathCursor(BufferView & bv);
#endif
projects / lyx.git / blobdiff