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(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 &);
  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 maple(MapleStream &) const;
  73         ///
  74         void mathmlize(MathStream &) const;
  75         ///
  76         void octave(OctaveStream &) const;
  77         ///
  78         void infoize(odocstream &) const;
  79         ///
  80         void infoize2(odocstream &) const;
  81
  82         /// fold the macro in the next metrics call
  83         void fold(Cursor & cur);
  84         /// unfold the macro in the next metrics call
  85         void unfold(Cursor & cur);
  86         /// will it be folded or unfolded in the next metric call?
  87         bool folded() const;
  88
  89         enum DisplayMode {
  90                 DISPLAY_INIT,
  91                 DISPLAY_INTERACTIVE_INIT,
  92                 DISPLAY_UNFOLDED,
  93                 DISPLAY_NORMAL,
  94         };
  95
  96         ///
  97         DisplayMode displayMode() const { return displayMode_; }
  98
  99         ///
 100         bool extraBraces() const { return displayMode_ == DISPLAY_NORMAL && arity() > 0; }
 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         size_t 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() const;
 131         /// update macro definition
 132         void updateMacro(MacroContext const & mc);
 133         /// check if macro definition changed, argument changed etc. and adapt
 134         void updateRepresentation(Cursor const * bvCur);
 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         MacroData const * macro() { return macro_; }
 143         ///
 144         bool editMetrics(BufferView const * bv) const;
 145
 146 private:
 147         ///
 148         virtual Inset * clone() const;
 149         ///
 150         bool editMode(BufferView const * bv) const;
 151
 152         /// name of macro
 153         docstring name_;
 154         /// current display mode
 155         DisplayMode displayMode_;
 156         /// expanded macro with ArgumentProxies
 157         InsetMathSqrt expanded_;
 158         /// macro definition with #1,#2,.. insets
 159         MathData definition_;
 160         /// number of arguments that were really attached
 161         size_t attachedArgsNum_;
 162         /// optional argument attached? (only in DISPLAY_NORMAL mode)
 163         size_t optionals_;
 164         /// fold mode to be set in next metrics call?
 165         bool nextFoldMode_;
 166         /// if macro_ == true, then here is a copy of the macro
 167         /// don't use it for locking
 168         MacroData macroBackup_;
 169         /// if macroNotFound_ == false, then here is a reference to the macro
 170         /// this might invalidate after metrics was called
 171         MacroData const * macro_;
 172         ///
 173         mutable std::map<BufferView const *, bool> editing_;
 174         ///
 175         std::string requires_;
 176         /// update macro representation
 177         bool needsUpdate_;
 178
 179 public:
 180         ///
 181         bool completionSupported(Cursor const &) const;
 182         ///
 183         bool inlineCompletionSupported(Cursor const & cur) const;
 184         ///
 185         bool automaticInlineCompletion() const;
 186         ///
 187         bool automaticPopupCompletion() const;
 188         ///
 189         CompletionListPtr completionList(Cursor const & cur) const;
 190         ///
 191         docstring completionPrefix(Cursor const & cur) const;
 192         ///
 193         bool insertCompletion(Cursor & cur, docstring const & s, bool finished);
 194         ///
 195         void completionPosAndDim(Cursor const &, int & x, int & y, Dimension & dim) const;
 196 };
 197
 198 } // namespace lyx
 199 #endif