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
  26 /** Extracted from Matthias notes:
  27  *
  28  * An inset can simple call LockInset in it's edit call and *ONLY*
  29  * in it's edit call.
  30  *
  31  * Unlocking is either done by LyX or the inset itself with a
  32  * UnlockInset-call
  33  *
  34  * During the lock, all button and keyboard events will be modified
  35  * and send to the inset through the following inset-features. Note that
  36  * InsetOld::insetUnlock will be called from inside UnlockInset. It is meant
  37  * to contain the code for restoring the menus and things like this.
  38  *
  39  * If a inset wishes any redraw and/or update it just has to call
  40  * updateInset(this).
  41  *
  42  * It's is completly irrelevant, where the inset is. UpdateInset will
  43  * find it in any paragraph in any buffer.
  44  * Of course the_locking_inset and the insets in the current paragraph/buffer
  45  *  are checked first, so no performance problem should occur.
  46  */
  47 class UpdatableInset : public InsetOld {
  48 public:
  49         ///
  50         UpdatableInset();
  51         ///
  52         UpdatableInset(UpdatableInset const & in);
  53
  54         /// check if the font of the char we want inserting is correct
  55         /// and modify it if it is not.
  56         virtual bool checkInsertChar(LyXFont &);
  57         ///
  58         virtual EDITABLE editable() const;
  59
  60         ///
  61         virtual void fitInsetCursor(BufferView *) const;
  62         /// FIXME
  63         virtual void getCursorPos(BufferView *, int &, int &) const {}
  64         /// Get the absolute document x,y of the cursor
  65         virtual void getCursor(BufferView &, int &, int &) const = 0;
  66         ///
  67         virtual void insetUnlock(BufferView *);
  68         ///
  69         virtual void draw(PainterInfo & pi, int x, int y) const;
  70         ///
  71         virtual bool insertInset(BufferView *, InsetOld *) { return false; }
  72         ///
  73         virtual UpdatableInset * getLockingInset() const {
  74                 return const_cast<UpdatableInset *>(this);
  75         }
  76         ///
  77         virtual UpdatableInset * getFirstLockingInsetOfType(InsetOld::Code c)
  78                 { return (c == lyxCode()) ? this : 0; }
  79         ///
  80         virtual int insetInInsetY() const { return 0; }
  81         ///
  82         virtual bool updateInsetInInset(BufferView *, InsetOld *)
  83                 { return false; }
  84         ///
  85         virtual bool lockInsetInInset(BufferView *, UpdatableInset *)
  86                 { return false; }
  87         ///
  88         virtual bool unlockInsetInInset(BufferView *, UpdatableInset *,
  89                                         bool /*lr*/ = false)
  90                 { return false; }
  91         ///  An updatable inset could handle lyx editing commands
  92         virtual RESULT localDispatch(FuncRequest const & cmd);
  93         ///
  94         int scroll(bool recursive = true) const {
  95                 // We need this method to not clobber the real method in Inset
  96                 return InsetOld::scroll(recursive);
  97         }
  98         ///
  99         virtual bool showInsetDialog(BufferView *) const { return false; }
 100         ///
 101         virtual void nodraw(bool b) const {
 102                 block_drawing_ = b;
 103         }
 104         ///
 105         virtual bool nodraw() const {
 106                 return block_drawing_;
 107         }
 108         ///
 109         // needed for spellchecking text
 110         ///
 111         virtual bool allowSpellcheck() const { return false; }
 112         ///
 113         virtual WordLangTuple const
 114         selectNextWordToSpellcheck(BufferView *, float & value) const;
 115         ///
 116         virtual void selectSelectedWord(BufferView *) {}
 117         ///
 118         virtual void toggleSelection(BufferView *, bool /*kill_selection*/) {}
 119
 120         /// find the next change in the inset
 121         virtual bool nextChange(BufferView * bv, lyx::pos_type & length);
 122
 123         ///
 124         // needed for search/replace functionality
 125         ///
 126         virtual bool searchForward(BufferView *, string const &,
 127                                    bool = true, bool = false);
 128         ///
 129         virtual bool searchBackward(BufferView *, string const &,
 130                                     bool = true, bool = false);
 131
 132 protected:
 133         /// scrolls to absolute position in bufferview-workwidth * sx units
 134         void scroll(BufferView *, float sx) const;
 135         /// scrolls offset pixels
 136         void scroll(BufferView *, int offset) const;
 137
 138 private:
 139         ///
 140         mutable bool block_drawing_;
 141 };
 142
 143 inline
 144 bool UpdatableInset::checkInsertChar(LyXFont &)
 145 {
 146         return true;
 147 }
 148
 149 #endif