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 #include <map>
  22
  23 namespace lyx {
  24
  25 /// This class contains the data for a macro.
  26 class MathMacro : public InsetMathNest {
  27 public:
  28         /// A macro can be built from an existing template
  29         MathMacro(Buffer * buf, docstring const & name);
  30         ///
  31         virtual MathMacro * asMacro() { return this; }
  32         ///
  33         virtual MathMacro const * asMacro() const { return this; }
  34         ///
  35         void draw(PainterInfo & pi, int x, int y) const;
  36         /// draw selection background
  37         void drawSelection(PainterInfo & pi, int x, int y) const;
  38         /// draw decorations.
  39         void drawDecoration(PainterInfo & pi, int x, int y) const
  40         { drawMarkers2(pi, x, y); }
  41         ///
  42         void metrics(MetricsInfo & mi, Dimension & dim) const;
  43         ///
  44         int kerning(BufferView const * bv) const;
  45         /// get cursor position
  46         void cursorPos(BufferView const & bv, CursorSlice const & sl,
  47                 bool boundary, int & x, int & y) const;
  48         ///
  49         void edit(Cursor & cur, bool front, EntryDirection entry_from);
  50         ///
  51         Inset * editXY(Cursor & cur, int x, int y);
  52
  53         /// target pos when we enter the inset while moving forward
  54         bool idxFirst(Cursor &) const;
  55         /// target pos when we enter the inset while moving backwards
  56         bool idxLast(Cursor &) const;
  57
  58         ///
  59         virtual bool notifyCursorLeaves(Cursor const & old, Cursor & cur);
  60
  61         /// Remove cell (starting from 0)
  62         void removeArgument(pos_type pos);
  63         /// Insert empty cell (starting from 0)
  64         void insertArgument(pos_type pos);
  65
  66         ///
  67         void validate(LaTeXFeatures &) const;
  68
  69         ///
  70         void write(WriteStream & os) const;
  71         ///
  72         void normalize(NormalStream & os) const;
  73         ///
  74         void maple(MapleStream &) const;
  75         ///
  76         void mathmlize(MathStream &) const;
  77         ///
  78         void htmlize(HtmlStream &) const;
  79         ///
  80         void octave(OctaveStream &) const;
  81         ///
  82         void infoize(odocstream &) const;
  83         ///
  84         void infoize2(odocstream &) const;
  85
  86         /// fold the macro in the next metrics call
  87         void fold(Cursor & cur);
  88         /// unfold the macro in the next metrics call
  89         void unfold(Cursor & cur);
  90         /// will it be folded or unfolded in the next metric call?
  91         bool folded() const;
  92
  93         enum DisplayMode {
  94                 DISPLAY_INIT,
  95                 DISPLAY_INTERACTIVE_INIT,
  96                 DISPLAY_UNFOLDED,
  97                 DISPLAY_NORMAL
  98         };
  99
 100         ///
 101         DisplayMode displayMode() const { return displayMode_; }
 102
 103         ///
 104         bool extraBraces() const { return displayMode_ == DISPLAY_NORMAL && arity() > 0; }
 105
 106         ///
 107         docstring name() const;
 108         ///
 109         bool validName() const;
 110         ///
 111         size_t arity() const {
 112                 if (displayMode_ == DISPLAY_NORMAL )
 113                         return cells_.size();
 114                 else
 115                         return 0;
 116         }
 117
 118         ///
 119         size_t optionals() const { return optionals_; }
 120         ///
 121         void setOptionals(int n) {
 122                 if (n <= int(nargs()))
 123                         optionals_ = n;
 124         }
 125         /// Return the maximal number of arguments the macro is greedy for.
 126         size_t appetite() const { return appetite_; }
 127         ///
 128         InsetCode lyxCode() const { return MATH_MACRO_CODE; }
 129
 130 protected:
 131         friend class MathData;
 132         friend class ArgumentProxy;
 133         friend class Cursor;
 134
 135         /// update the display mode (should only be called after detaching arguments)
 136         void setDisplayMode(DisplayMode mode, int appetite = -1);
 137         /// compute the next display mode
 138         DisplayMode computeDisplayMode() const;
 139         /// update macro definition
 140         void updateMacro(MacroContext const & mc);
 141         /// check if macro definition changed, argument changed etc. and adapt
 142         void updateRepresentation(Cursor * cur, MacroContext const & mc, UpdateType);
 143         /// empty macro, put arguments into args, possibly strip arity-attachedArgsNum_ empty ones.
 144         /// Includes the optional arguments.
 145         void detachArguments(std::vector<MathData> & args, bool strip);
 146         /// attach arguments (maybe less than arity at the end of an MathData),
 147         /// including the optional ones (even if it can be empty here)
 148         void attachArguments(std::vector<MathData> const & args, size_t arity, int optionals);
 149         ///
 150         MacroData const * macro() { return macro_; }
 151         ///
 152         bool editMetrics(BufferView const * bv) const;
 153
 154 private:
 155         ///
 156         virtual Inset * clone() const;
 157         ///
 158         bool editMode(BufferView const * bv) const;
 159
 160         /// name of macro
 161         docstring name_;
 162         /// current display mode
 163         DisplayMode displayMode_;
 164         /// expanded macro with ArgumentProxies
 165         InsetMathSqrt expanded_;
 166         /// macro definition with #1,#2,.. insets
 167         MathData definition_;
 168         /// number of arguments that were really attached
 169         size_t attachedArgsNum_;
 170         /// optional argument attached? (only in DISPLAY_NORMAL mode)
 171         size_t optionals_;
 172         /// fold mode to be set in next metrics call?
 173         bool nextFoldMode_;
 174         /// if macro_ == true, then here is a copy of the macro
 175         /// don't use it for locking
 176         MacroData macroBackup_;
 177         /// if macroNotFound_ == false, then here is a reference to the macro
 178         /// this might invalidate after metrics was called
 179         MacroData const * macro_;
 180         ///
 181         mutable std::map<BufferView const *, bool> editing_;
 182         ///
 183         std::string requires_;
 184         /// update macro representation
 185         bool needsUpdate_;
 186         /// maximal number of arguments the macro is greedy for
 187         size_t appetite_;
 188
 189 public:
 190         ///
 191         bool completionSupported(Cursor const &) const;
 192         ///
 193         bool inlineCompletionSupported(Cursor const & cur) const;
 194         ///
 195         bool automaticInlineCompletion() const;
 196         ///
 197         bool automaticPopupCompletion() const;
 198         ///
 199         CompletionList const * createCompletionList(Cursor const & cur) const;
 200         ///
 201         docstring completionPrefix(Cursor const & cur) const;
 202         ///
 203         bool insertCompletion(Cursor & cur, docstring const & s, bool finished);
 204         ///
 205         void completionPosAndDim(Cursor const &, int & x, int & y, Dimension & dim) const;
 206 };
 207
 208 } // namespace lyx
 209 #endif