src/insets/updatableinset.h

   1 // -*- C++ -*-
   2 /**
   3  * \file updatableinset.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 Jürgen Vigna
   9  * \author Lars Gullik Bjønnes
  10  * \author Matthias Ettrich
  11  *
  12  * Full author contact details are available in file CREDITS.
  13  */
  14
  15 #ifndef UPDATABLEINSET_H
  16 #define UPDATABLEINSET_H
  17
  18 //  Updatable Insets. These insets can be locked and receive
  19 //  directly user interaction. Currently used only for mathed.
  20 //  Note that all pure methods from Inset class are pure here too.
  21 //  [Alejandro 080596]
  22
  23 #include "inset.h"
  24
  25 #include "support/types.h"
  26
  27
  28 /** Extracted from Matthias notes:
  29  *
  30  * An inset can simple call LockInset in it's edit call and *ONLY*
  31  * in it's edit call.
  32  *
  33  * Unlocking is either done by LyX or the inset itself with a
  34  * UnlockInset-call
  35  *
  36  * During the lock, all button and keyboard events will be modified
  37  * and send to the inset through the following inset-features. Note that
  38  * InsetOld::insetUnlock will be called from inside UnlockInset. It is meant
  39  * to contain the code for restoring the menus and things like this.
  40  *
  41  * If a inset wishes any redraw and/or update it just has to call
  42  * updateInset(this).
  43  *
  44  * It's is completly irrelevant, where the inset is. UpdateInset will
  45  * find it in any paragraph in any buffer.
  46  * Of course the_locking_inset and the insets in the current paragraph/buffer
  47  *  are checked first, so no performance problem should occur.
  48  */
  49 class UpdatableInset : public InsetOld {
  50 public:
  51         /// check if the font of the char we want inserting is correct
  52         /// and modify it if it is not.
  53         virtual bool checkInsertChar(LyXFont &) { return true; }
  54         ///
  55         virtual EDITABLE editable() const;
  56
  57         ///
  58         virtual void fitInsetCursor(BufferView *) const;
  59         /// FIXME
  60         virtual void getCursorPos(BufferView *, int &, int &) const {}
  61         /// Get the absolute document x,y of the cursor
  62         virtual void getCursor(BufferView &, int &, int &) const = 0;
  63         ///
  64         virtual void insetUnlock(BufferView *);
  65         ///
  66         virtual void draw(PainterInfo & pi, int x, int y) const;
  67         ///
  68         virtual bool insertInset(BufferView *, InsetOld *) { return false; }
  69         ///
  70         virtual UpdatableInset * getLockingInset() const
  71                 { return const_cast<UpdatableInset *>(this); }
  72         ///
  73         virtual UpdatableInset * getFirstLockingInsetOfType(InsetOld::Code c)
  74                 { return (c == lyxCode()) ? this : 0; }
  75         ///
  76         virtual int insetInInsetY() const { return 0; }
  77         ///
  78         virtual bool lockInsetInInset(BufferView *, UpdatableInset *)
  79                 { return false; }
  80         ///
  81         virtual bool unlockInsetInInset(BufferView *, UpdatableInset *,
  82                                         bool /*lr*/ = false)
  83                 { return false; }
  84         ///  An updatable inset could handle lyx editing commands
  85         virtual dispatch_result localDispatch(FuncRequest const & cmd);
  86         // We need this method to not clobber the real method in Inset
  87         int scroll(bool recursive = true) const
  88                 { return InsetOld::scroll(recursive); }
  89         ///
  90         virtual bool showInsetDialog(BufferView *) const { return false; }
  91         ///
  92         // needed for spellchecking text
  93         ///
  94         virtual bool allowSpellcheck() const { return false; }
  95         ///
  96         virtual WordLangTuple const
  97         selectNextWordToSpellcheck(BufferView *, float & value) const;
  98         ///
  99         virtual void selectSelectedWord(BufferView *) {}
 100         ///
 101         virtual void toggleSelection(BufferView *, bool /*kill_selection*/) {}
 102
 103         /// find the next change in the inset
 104         virtual bool nextChange(BufferView * bv, lyx::pos_type & length);
 105
 106         ///
 107         // needed for search/replace functionality
 108         ///
 109         virtual bool searchForward(BufferView *, std::string const &,
 110                                    bool = true, bool = false);
 111         ///
 112         virtual bool searchBackward(BufferView *, std::string const &,
 113                                     bool = true, bool = false);
 114
 115 protected:
 116         /// scrolls to absolute position in bufferview-workwidth * sx units
 117         void scroll(BufferView *, float sx) const;
 118         /// scrolls offset pixels
 119         void scroll(BufferView *, int offset) const;
 120 };
 121
 122 #endif