mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-09-21 15:18:45 +00:00
a105cf94a9
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@7291 a592a061-630c-0410-9148-cb99ea01b6c8
308 lines
8.2 KiB
C++
308 lines
8.2 KiB
C++
// -*- 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
|
|
*
|
|
* Dependencies: Xlib, XForms
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#ifndef MATH_CURSOR
|
|
#define MATH_CURSOR
|
|
|
|
|
|
#include "math_inset.h"
|
|
#include "math_iterator.h"
|
|
#include "LString.h"
|
|
|
|
class InsetFormulaBase;
|
|
class BufferView;
|
|
class PainterInfo;
|
|
class MathUnknownInset;
|
|
|
|
/**
|
|
|
|
[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 CursorPos, 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;
|
|
/// type for column numbers
|
|
typedef MathArray::difference_type difference_type;
|
|
/// type for cursor positions within a cell
|
|
typedef MathInset::pos_type pos_type;
|
|
/// type for cell indices
|
|
typedef MathInset::idx_type idx_type;
|
|
/// type for row numbers
|
|
typedef MathInset::row_type row_type;
|
|
/// type for column numbers
|
|
typedef MathInset::col_type col_type;
|
|
|
|
///
|
|
explicit MathCursor(InsetFormulaBase *, bool left);
|
|
///
|
|
~MathCursor();
|
|
///
|
|
void insert(MathAtom const &);
|
|
///
|
|
void insert(MathArray const &);
|
|
///
|
|
void insert2(string const &);
|
|
///
|
|
void paste(string const & data);
|
|
/// return false for empty math insets
|
|
bool erase();
|
|
/// return false for empty math insets
|
|
bool backspace();
|
|
/// called for LFUN_HOME etc
|
|
bool home(bool sel = false);
|
|
/// called for LFUN_END etc
|
|
bool end(bool sel = false);
|
|
/// called for LFUN_RIGHT and LFUN_RIGHTSEL
|
|
bool right(bool sel = false);
|
|
/// called for LFUN_LEFT etc
|
|
bool left(bool sel = false);
|
|
/// called for LFUN_UP etc
|
|
bool up(bool sel = false);
|
|
/// called for LFUN_DOWN etc
|
|
bool down(bool sel = false);
|
|
/// Put the cursor in the first position
|
|
void first();
|
|
/// Put the cursor in the last position
|
|
void last();
|
|
/// move to next cell in current inset
|
|
void idxNext();
|
|
/// move to previous cell in current inset
|
|
void idxPrev();
|
|
///
|
|
void plainErase();
|
|
///
|
|
void plainInsert(MathAtom const &);
|
|
///
|
|
void niceInsert(MathAtom const &);
|
|
///
|
|
void niceInsert(string const &);
|
|
|
|
/// in pixels from top of screen
|
|
void setPos(int x, int y);
|
|
/// in pixels from top of screen
|
|
void getPos(int & x, int & y) const;
|
|
/// in pixels from left of screen
|
|
int targetX() const;
|
|
/// current inset
|
|
MathInset * inset() const;
|
|
/// return the next enclosing grid inset and the cursor's index in it
|
|
MathGridInset * enclosingGrid(idx_type & idx) const;
|
|
/// go up to enclosing grid
|
|
void popToEnclosingGrid();
|
|
/// go up to the hull inset
|
|
void popToEnclosingHull();
|
|
/// go up to the hull inset
|
|
void popToHere(MathInset const * p);
|
|
/// adjust anchor position after deletions/insertions
|
|
void adjust(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 interpret(char);
|
|
/// interpret name a name of a macro
|
|
void macroModeClose();
|
|
/// are we currently typing the name of a macro?
|
|
bool inMacroMode() const;
|
|
/// get access to the macro we are currently typing
|
|
MathUnknownInset * activeMacro();
|
|
/// get access to the macro we are currently typing
|
|
MathUnknownInset const * activeMacro() const;
|
|
/// are we currently typing '#1' or '#2' or...?
|
|
bool inMacroArgMode() const;
|
|
/// are we in math mode (1), text mode (-1) or unsure?
|
|
MathInset::mode_type currentMode() const;
|
|
|
|
// Local selection methods
|
|
///
|
|
bool selection() const;
|
|
///
|
|
void selCopy();
|
|
///
|
|
void selCut();
|
|
///
|
|
void selDel();
|
|
/// pastes n-th element of cut buffer
|
|
void selPaste(size_t n);
|
|
///
|
|
void selHandle(bool);
|
|
///
|
|
void selStart();
|
|
///
|
|
void selClear();
|
|
/// clears or deletes selection depending on lyxrc setting
|
|
void selClearOrDel();
|
|
/// draws light-blue selection background
|
|
void drawSelection(PainterInfo & pi) const;
|
|
///
|
|
void handleNest(MathAtom const & at);
|
|
/// remove this as soon as LyXFunc::getStatus is "localized"
|
|
string getLastCode() const { return "mathnormal"; }
|
|
///
|
|
bool isInside(MathInset const *) const;
|
|
///
|
|
char valign() const;
|
|
///
|
|
char halign() const;
|
|
|
|
/// make sure cursor position is valid
|
|
void normalize();
|
|
/// mark current cursor trace for redraw
|
|
void touch();
|
|
///
|
|
UpdatableInset * asHyperActiveInset() const;
|
|
|
|
/// enter a MathInset
|
|
void push(MathAtom & par);
|
|
/// enter a MathInset from the front
|
|
void pushLeft(MathAtom & par);
|
|
/// enter a MathInset from the back
|
|
void pushRight(MathAtom & par);
|
|
/// leave current MathInset to the left
|
|
bool popLeft();
|
|
/// leave current MathInset to the left
|
|
bool popRight();
|
|
|
|
///
|
|
MathArray & array() const;
|
|
///
|
|
bool hasPrevAtom() const;
|
|
///
|
|
bool hasNextAtom() const;
|
|
///
|
|
MathAtom const & prevAtom() const;
|
|
///
|
|
MathAtom & prevAtom();
|
|
///
|
|
MathAtom const & nextAtom() const;
|
|
///
|
|
MathAtom & nextAtom();
|
|
|
|
/// returns the selection
|
|
void getSelection(CursorPos &, CursorPos &) const;
|
|
/// returns the normalized anchor of the selection
|
|
CursorPos normalAnchor() const;
|
|
|
|
/// reference to the last item of the path, i.e. "The Cursor"
|
|
CursorPos & cursor();
|
|
/// reference to the last item of the path, i.e. "The Cursor"
|
|
CursorPos const & cursor() const;
|
|
/// how deep are we nested?
|
|
unsigned depth() const;
|
|
|
|
/// local dispatcher
|
|
dispatch_result dispatch(FuncRequest const & cmd);
|
|
/// describe the situation
|
|
string info() 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);
|
|
/// grab selection marked by anchor and current cursor
|
|
string grabSelection() const;
|
|
/// guess what
|
|
string grabAndEraseSelection();
|
|
///
|
|
void insert(char c);
|
|
///
|
|
void insert(string const & str);
|
|
/// lock/unlock inset
|
|
void insetToggle();
|
|
|
|
/// hack for reveal codes
|
|
void markInsert();
|
|
void markErase();
|
|
/// injects content of a cell into parent
|
|
void pullArg();
|
|
/// split font inset etc
|
|
void handleFont(string const & font);
|
|
|
|
private:
|
|
/// moves cursor index one cell to the left
|
|
bool idxLeft();
|
|
/// moves cursor index one cell to the right
|
|
bool idxRight();
|
|
/// moves cursor to end of last cell of current line
|
|
bool idxLineLast();
|
|
/// moves cursor position one cell to the left
|
|
bool posLeft();
|
|
/// moves cursor position one cell to the right
|
|
bool posRight();
|
|
/// moves position somehow up or down
|
|
bool goUpDown(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);
|
|
/// moves position closest to (x, y) in current cell
|
|
void bruteFind2(int x, int y);
|
|
/// are we in a nucleus of a script inset?
|
|
bool inNucleus() const;
|
|
|
|
/// erase the selected part and re-sets the cursor
|
|
void eraseSelection();
|
|
|
|
/// the name of the macro we are currently inputting
|
|
string macroName() const;
|
|
/// where in the curent cell does the macro name start?
|
|
difference_type macroNamePos() 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
|
|
/// text code of last char entered
|
|
//MathTextCodes lastcode_;
|
|
/// do we allow autocorrection
|
|
bool autocorrect_;
|
|
/// do we currently select
|
|
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);
|
|
|
|
#endif
|