src/mathed/MathMacro.h

   1 // -*- C++ -*-
   2 /**
   3  * \file MathMacro.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Alejandro Aguilar Sierra
   8  * \author André Pönitz
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  */
  12
  13 #ifndef MATH_MACRO_H
  14 #define MATH_MACRO_H
  15
  16 #include "InsetMathNest.h"
  17 #include "InsetMathSqrt.h"
  18 #include "MacroTable.h"
  19 #include "MathData.h"
  20
  21 namespace lyx {
  22
  23
  24 /// This class contains the data for a macro.
  25 class MathMacro : public InsetMathNest {
  26 public:
  27         /// A macro can be built from an existing template
  28         MathMacro(docstring const & name);
  29         ///
  30         virtual MathMacro * asMacro() { return this; }
  31         ///
  32         virtual MathMacro const * asMacro() const { return this; }
  33         ///
  34         void draw(PainterInfo & pi, int x, int y) const;
  35         /// draw selection background
  36         void drawSelection(PainterInfo & pi, int x, int y) const;
  37         /// draw decorations.
  38         void drawDecoration(PainterInfo & pi, int x, int y) const
  39         { drawMarkers2(pi, x, y); }
  40         ///
  41         void metrics(MetricsInfo & mi, Dimension & dim) const;
  42         ///
  43         int kerning() const;
  44         /// get cursor position
  45         void cursorPos(BufferView const & bv, CursorSlice const & sl,
  46                 bool boundary, int & x, int & y) const;
  47         ///
  48         void edit(Cursor & cur, bool left);
  49         ///
  50         Inset * editXY(Cursor & cur, int x, int y);
  51
  52         /// target pos when we enter the inset from the left by pressing "Right"
  53         bool idxFirst(Cursor &) const;
  54         /// target pos when we enter the inset from the right by pressing "Left"
  55         bool idxLast(Cursor &) const;
  56
  57         ///
  58         virtual bool notifyCursorLeaves(Cursor &);
  59
  60         /// Remove cell (starting from 0)
  61         void removeArgument(size_t pos);
  62         /// Insert empty cell (starting from 0)
  63         void insertArgument(size_t pos);
  64
  65         ///
  66         void validate(LaTeXFeatures &) const;
  67
  68         ///
  69         void write(WriteStream & os) const;
  70         ///
  71         void maple(MapleStream &) const;
  72         ///
  73         void mathmlize(MathStream &) const;
  74         ///
  75         void octave(OctaveStream &) const;
  76         ///
  77         void infoize(odocstream &) const;
  78         ///
  79         void infoize2(odocstream &) const;
  80
  81         /// fold the macro in the next metrics call
  82         void fold(Cursor & cur);
  83         /// unfold the macro in the next metrics call
  84         void unfold(Cursor & cur);
  85         /// will it be folded or unfolded in the next metric call?
  86         bool folded() const;
  87
  88         enum DisplayMode {
  89                 DISPLAY_INIT,
  90                 DISPLAY_NONGREEDY_INIT,
  91                 DISPLAY_UNFOLDED,
  92                 DISPLAY_NORMAL,
  93         };
  94
  95         ///
  96         DisplayMode displayMode() const { return displayMode_; }
  97
  98         ///
  99         bool extraBraces() const { return displayMode_ == DISPLAY_NORMAL && arity() > 0; }
 100
 101
 102         ///
 103         docstring name() const;
 104         ///
 105         bool validName() const;
 106         ///
 107         size_t arity() const {
 108                 if (displayMode_ == DISPLAY_NORMAL )
 109                         return cells_.size();
 110                 else
 111                         return 0;
 112         }
 113
 114         ///
 115         int optionals() const { return optionals_; }
 116         ///
 117         void setOptionals(int n) {
 118                 if (n <= int(nargs()))
 119                         optionals_ = n;
 120         }
 121
 122 protected:
 123         friend class MathData;
 124         friend class ArgumentProxy;
 125         friend class Cursor;
 126
 127         /// update the display mode (should only be called after detaching arguments)
 128         void setDisplayMode(DisplayMode mode);
 129         /// compute the next display mode
 130         DisplayMode computeDisplayMode(MetricsInfo const & mi) const;
 131         /// update macro definition
 132         void updateMacro(MetricsInfo & mi);
 133         /// check if macro definition changed, argument changed etc. and adapt
 134         void updateRepresentation(MetricsInfo & mi);
 135         /// empty macro, put arguments into args, possibly strip arity-attachedArgsNum_ empty ones.
 136         /// Includes the optional arguments.
 137         void detachArguments(std::vector<MathData> & args, bool strip);
 138         /// attach arguments (maybe less than arity at the end of an MathData),
 139         /// including the optional ones (even if it can be empty here)
 140         void attachArguments(std::vector<MathData> const & args, size_t arity, int optionals);
 141         ///
 142         bool editing() { return editing_; }
 143         ///
 144         MacroData const * macro() { return macro_; }
 145
 146 private:
 147         ///
 148         virtual Inset * clone() const;
 149         /// the index of the cursor slice of the macro, or -1 if it is not edited
 150         int cursorIdx(Cursor const & cur) const;
 151         ///
 152         bool editMode(Cursor const & cur) const;
 153
 154         /// name of macro
 155         docstring name_;
 156         /// current display mode
 157         DisplayMode displayMode_;
 158         /// display mode before change
 159         InsetMathSqrt expanded_;
 160         /// number of arguments that were really attached
 161         size_t attachedArgsNum_;
 162         /// cursor position during last draw
 163         int previousCurIdx_;
 164         /// optional argument attached? (only in DISPLAY_NORMAL mode)
 165         int optionals_;
 166         /// fold mode to be set in next metrics call?
 167         bool nextFoldMode_;
 168         /// if macro_ == true, then here is a copy of the macro
 169         /// don't use it for locking
 170         MacroData macroBackup_;
 171         /// if macroNotFound_ == false, then here is a reference to the macro
 172         /// this might invalidate after metrics was called
 173         MacroData const * macro_;
 174         ///
 175         bool editing_;
 176         ///
 177         std::string requires_;
 178         /// update macro representation
 179         bool needsUpdate_;
 180 };
 181
 182 } // namespace lyx
 183 #endif