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 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 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         /// Return the maximal number of arguments the macro is greedy for.
 122         size_t appetite() const { return appetite_; }
 123
 124 protected:
 125         friend class MathData;
 126         friend class ArgumentProxy;
 127         friend class Cursor;
 128
 129         /// update the display mode (should only be called after detaching arguments)
 130         void setDisplayMode(DisplayMode mode, int appetite = -1);
 131         /// compute the next display mode
 132         DisplayMode computeDisplayMode() const;
 133         /// update macro definition
 134         void updateMacro(MacroContext const & mc);
 135         /// check if macro definition changed, argument changed etc. and adapt
 136         void updateRepresentation();
 137         /// empty macro, put arguments into args, possibly strip arity-attachedArgsNum_ empty ones.
 138         /// Includes the optional arguments.
 139         void detachArguments(std::vector<MathData> & args, bool strip);
 140         /// attach arguments (maybe less than arity at the end of an MathData),
 141         /// including the optional ones (even if it can be empty here)
 142         void attachArguments(std::vector<MathData> const & args, size_t arity, int optionals);
 143         ///
 144         MacroData const * macro() { return macro_; }
 145         ///
 146         bool editMetrics(BufferView const * bv) const;
 147
 148 private:
 149         ///
 150         virtual Inset * clone() const;
 151         ///
 152         bool editMode(BufferView const * bv) const;
 153
 154         /// name of macro
 155         docstring name_;
 156         /// current display mode
 157         DisplayMode displayMode_;
 158         /// expanded macro with ArgumentProxies
 159         InsetMathSqrt expanded_;
 160         /// macro definition with #1,#2,.. insets
 161         MathData definition_;
 162         /// number of arguments that were really attached
 163         size_t attachedArgsNum_;
 164         /// optional argument attached? (only in DISPLAY_NORMAL mode)
 165         size_t 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         mutable std::map<BufferView const *, bool> editing_;
 176         ///
 177         std::string requires_;
 178         /// update macro representation
 179         bool needsUpdate_;
 180         /// maximal number of arguments the macro is greedy for
 181         size_t appetite_;
 182
 183 public:
 184         ///
 185         bool completionSupported(Cursor const &) const;
 186         ///
 187         bool inlineCompletionSupported(Cursor const & cur) const;
 188         ///
 189         bool automaticInlineCompletion() const;
 190         ///
 191         bool automaticPopupCompletion() const;
 192         ///
 193         CompletionList const * createCompletionList(Cursor const & cur) const;
 194         ///
 195         docstring completionPrefix(Cursor const & cur) const;
 196         ///
 197         bool insertCompletion(Cursor & cur, docstring const & s, bool finished);
 198         ///
 199         void completionPosAndDim(Cursor const &, int & x, int & y, Dimension & dim) const;
 200 };
 201
 202 } // namespace lyx
 203 #endif