X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finset.h;h=aae88009d78c4c7e8be4955fcd897013adda9cab;hb=4a5b7a5952ad2381fcdf4830511293e184c7c5a1;hp=a332baecf7087166c22644b81e59959721b5ad95;hpb=d1182f17daa1a164d9527ccbe6500840d7ac6bc8;p=lyx.git diff --git a/src/insets/inset.h b/src/insets/inset.h index a332baecf7..aae88009d7 100644 --- a/src/insets/inset.h +++ b/src/insets/inset.h @@ -19,6 +19,7 @@ #include "LString.h" #include #include "commandtags.h" +#include "LColor.h" class LyXFont; class BufferView; @@ -26,6 +27,8 @@ class Buffer; class Painter; class LyXText; class LyXLex; +class Paragraph; +class LyXCursor; struct LaTeXFeatures; @@ -93,8 +96,10 @@ public: TABULAR_CODE, /// EXTERNAL_CODE, +#if 0 /// THEOREM_CODE, +#endif /// CAPTION_CODE, /// @@ -104,7 +109,9 @@ public: /// CITE_CODE, /// - FLOAT_LIST_CODE + FLOAT_LIST_CODE, + /// + INDEX_PRINT_CODE }; /// @@ -124,8 +131,10 @@ public: }; /// - Inset() : top_x(0), top_baseline(0), scx(0), owner_(0) {} - /// Virtual base destructor + Inset(); + /// + Inset(Inset const & in, bool same_id = false); + /// virtual ~Inset() {} /// virtual int ascent(BufferView *, LyXFont const &) const = 0; @@ -139,62 +148,71 @@ public: /// update the inset representation virtual void update(BufferView *, LyXFont const &, bool = false) {} - /// - virtual LyXFont const ConvertFont(LyXFont const & font) const; /// what appears in the minibuffer when opening - virtual string const EditMessage() const; + virtual string const editMessage() const; + /// + virtual void edit(BufferView *, int x, int y, unsigned int button); /// - virtual void Edit(BufferView *, int x, int y, unsigned int button); + virtual void edit(BufferView *, bool front = true); /// - virtual EDITABLE Editable() const; + virtual EDITABLE editable() const; /// This is called when the user clicks inside an inset - virtual void InsetButtonPress(BufferView *, int, int, int) {} + virtual void insetButtonPress(BufferView *, int, int, int) {} /// This is called when the user releases the button inside an inset - virtual void InsetButtonRelease(BufferView *, int, int, int) {} - /// This is caleld when the user moves the mouse inside an inset - virtual void InsetMotionNotify(BufferView *, int , int , int) {} + // the bool return is used to see if we opened a dialog so that we can + // check this from an outer inset and open the dialog of the outer inset + // if that one has one! + /// + virtual bool insetButtonRelease(BufferView *, int, int, int) + { return false; } + /// This is called when the user moves the mouse inside an inset + virtual void insetMotionNotify(BufferView *, int , int , int) {} /// - virtual bool IsTextInset() const { return false; } + virtual bool isTextInset() const { return false; } /// virtual bool doClearArea() const { return true; } /// - virtual bool AutoDelete() const; + virtual bool autoDelete() const; + /// returns true the inset can hold an inset of given type + virtual bool insetAllowed(Inset::Code) const { return false; } + /// wrapper around the above + bool insetAllowed(Inset * in) const; /// - virtual void Write(Buffer const *, std::ostream &) const = 0; + virtual void write(Buffer const *, std::ostream &) const = 0; /// - virtual void Read(Buffer const *, LyXLex & lex) = 0; + virtual void read(Buffer const *, LyXLex & lex) = 0; /** returns the number of rows (\n's) of generated tex code. fragile == true means, that the inset should take care about fragile commands by adding a \protect before. If the free_spc (freespacing) variable is set, then this inset is in a free-spacing paragraph. */ - virtual int Latex(Buffer const *, std::ostream &, bool fragile, + virtual int latex(Buffer const *, std::ostream &, bool fragile, bool free_spc) const = 0; /// - virtual int Ascii(Buffer const *, - std::ostream &, int linelen = 0) const = 0; + virtual int ascii(Buffer const *, + std::ostream &, int linelen = 0) const = 0; /// - virtual int Linuxdoc(Buffer const *, std::ostream &) const = 0; + virtual int linuxdoc(Buffer const *, std::ostream &) const = 0; /// - virtual int DocBook(Buffer const *, std::ostream &) const = 0; + virtual int docbook(Buffer const *, std::ostream &) const = 0; /// Updates needed features for this inset. - virtual void Validate(LaTeXFeatures & features) const; + virtual void validate(LaTeXFeatures & features) const; /// - virtual bool Deletable() const; + virtual bool deletable() const; /// returns LyX code associated with the inset. Used for TOC, ...) - virtual Inset::Code LyxCode() const { return NO_CODE; } + virtual Inset::Code lyxCode() const { return NO_CODE; } virtual std::vector const getLabelList() const { return std::vector(); } /// - virtual Inset * Clone(Buffer const &) const = 0; + virtual Inset * clone(Buffer const &, bool same_ids = false) const = 0; /// returns true to override begin and end inset in file - virtual bool DirectWrite() const; + virtual bool directWrite() const; /// Returns true if the inset should be centered alone virtual bool display() const { return false; } @@ -205,16 +223,22 @@ public: /// virtual bool needFullRow() const { return false; } /// - virtual bool InsertInsetAllowed(Inset *) const { return false; } + void setInsetName(string const & s) { name_ = s; } /// - void setInsetName(string const & s) { name = s; } - /// - string const getInsetName() const { return name; } + string const & getInsetName() const { return name_; } /// void setOwner(Inset * inset) { owner_ = inset; } /// Inset * owner() const { return owner_; } /// + void parOwner(Paragraph * par) { par_owner_ = par; } + /// + Paragraph * parOwner() const {return par_owner_; } + /// + void setBackgroundColor(LColor::color); + /// + LColor::color backgroundColor() const; + /// int x() const { return top_x; } /// int y() const { return top_baseline; } @@ -234,22 +258,110 @@ public: return scx; return 0; } + /// try to get a paragraph pointer from it's id if we have a + /// paragraph to give back! + virtual Paragraph * getParFromID(int /* id */) const { + return 0; + } + /// try to get a inset pointer from it's id if we have + /// an inset to give back! + virtual Inset * getInsetFromID(int /* id */) const { + return 0; + } + /// if this insets owns paragraphs (f.ex. InsetText) then it + /// should return it's very first one! + virtual Paragraph * firstParagraph() const { + return 0; + } + + /// + virtual Paragraph * getFirstParagraph(int /*num*/) const { + return 0; + } + + /// return the cursor if we own one otherwise giv'em just the + /// BufferView cursor to work with. + virtual LyXCursor const & cursor(BufferView * bview) const; + /// id functions + int id() const; + /// + void id(int id_arg); + + /// used to toggle insets + // is the inset open? + virtual bool isOpen() const { return false; } + /// open the inset + virtual void open(BufferView *) {} + /// close the inset + virtual void close(BufferView *) const {} + /// check if the font of the char we want inserting is correct + /// and modify it if it is not. + virtual bool checkInsertChar(LyXFont &); + /// we need this here because collapsed insets are only EDITABLE + virtual void setFont(BufferView *, LyXFont const &, + bool toggleall = false, bool selectall = false); + /// + // needed for spellchecking text + /// + virtual bool allowSpellcheck() { return false; } + + // should this inset be handled like a normal charater + virtual bool isChar() const { return false; } + // is this equivalent to a letter? + virtual bool isLetter() const { return false; } + // is this equivalent to a space (which is BTW different from + // a line separator)? + virtual bool isSpace() const { return false; } + // should we break lines after this inset? + virtual bool isLineSeparator() const { return false; } + // if this inset has paragraphs should they be output all as default + // paragraphs with "Standard" layout? + virtual bool forceDefaultParagraphs(Inset const *) const; + // needed for widths which are % of something + /* returns the value of \textwidth in this inset. Most of the + time this is the width of the workarea, but if there is a + minipage somewhere, it will be the width of this minipage */ + virtual int latexTextWidth(BufferView *) const; protected: /// mutable int top_x; /// + mutable bool topx_set; /* have we already drawn ourself! */ + /// mutable int top_baseline; /// mutable int scx; + /// + unsigned int id_; + /// + static unsigned int inset_id; + private: /// Inset * owner_; + /// the paragraph in which this inset has been inserted + Paragraph * par_owner_; /// - string name; + string name_; + /// + LColor::color background_color_; }; +inline +bool Inset::insetAllowed(Inset * in) const +{ + return insetAllowed(in->lyxCode()); +} + + +inline +bool Inset::checkInsertChar(LyXFont &) +{ + return false; +} + // Updatable Insets. These insets can be locked and receive // directly user interaction. Currently used only for mathed. // Note that all pure methods from Inset class are pure here too. @@ -265,7 +377,7 @@ private: * * During the lock, all button and keyboard events will be modified * and send to the inset through the following inset-features. Note that - * Inset::InsetUnlock will be called from inside UnlockInset. It is meant + * Inset::insetUnlock will be called from inside UnlockInset. It is meant * to contain the code for restoring the menus and things like this. * * If a inset wishes any redraw and/or update it just has to call @@ -283,19 +395,28 @@ public: becomes a bit complex, just two possible results (boolean) are not enough. - DISPATCHED = the inset catched the action + DISPATCHED = the inset catched the action DISPATCHED_NOUPDATE = the inset catched the action and no update is needed here to redraw the inset - FINISHED = the inset must be unlocked as a result - of the action - UNDISPATCHED = the action was not catched, it should be - dispatched by lower level insets + FINISHED = the inset must be unlocked as a result + of the action + FINISHED_RIGHT = FINISHED, but put the cursor to the RIGHT of + the inset. + FINISHED_UP = FINISHED, but put the cursor UP of + the inset. + FINISHED_DOWN = FINISHED, but put the cursor DOWN of + the inset. + UNDISPATCHED = the action was not catched, it should be + dispatched by lower level insets */ enum RESULT { UNDISPATCHED = 0, DISPATCHED, DISPATCHED_NOUPDATE, - FINISHED + FINISHED, + FINISHED_RIGHT, + FINISHED_UP, + FINISHED_DOWN }; /// To convert old binary dispatch results @@ -304,80 +425,110 @@ public: } /// - UpdatableInset() : cursor_visible_(false), block_drawing_(false) {} + UpdatableInset(); + /// + UpdatableInset(UpdatableInset const & in, bool same_id = false); + /// check if the font of the char we want inserting is correct + /// and modify it if it is not. + virtual bool checkInsertChar(LyXFont &); /// - virtual EDITABLE Editable() const; + virtual EDITABLE editable() const; /// may call ToggleLockedInsetCursor - virtual void ToggleInsetCursor(BufferView *); + virtual void toggleInsetCursor(BufferView *); /// - virtual void ShowInsetCursor(BufferView *, bool show = true); + virtual void showInsetCursor(BufferView *, bool show = true); /// - virtual void HideInsetCursor(BufferView *); + virtual void hideInsetCursor(BufferView *); /// - virtual void GetCursorPos(BufferView *, int &, int &) const {} + virtual void fitInsetCursor(BufferView *) const; /// - virtual void InsetButtonPress(BufferView *, int x, int y, int button); + virtual void getCursorPos(BufferView *, int &, int &) const {} /// - virtual void InsetButtonRelease(BufferView *, - int x, int y, int button); + virtual void insetButtonPress(BufferView *, int x, int y, int button); /// - virtual void InsetKeyPress(XKeyEvent * ev); + // the bool return is used to see if we opened a dialog so that we can + // check this from an outer inset and open the dialog of the outer inset + // if that one has one! /// - virtual void InsetMotionNotify(BufferView *, int x, int y, int state); + virtual bool insetButtonRelease(BufferView *, + int x, int y, int button); /// - virtual void InsetUnlock(BufferView *); + virtual void insetKeyPress(XKeyEvent * ev); /// - virtual void Edit(BufferView *, int x, int y, unsigned int button); + virtual void insetMotionNotify(BufferView *, int x, int y, int state); /// - virtual void draw(BufferView *, LyXFont const &, - int baseline, float & x, bool cleared) const; + virtual void insetUnlock(BufferView *); /// - virtual void SetFont(BufferView *, LyXFont const &, - bool toggleall = false, bool selectall = false); + virtual void edit(BufferView *, int x, int y, unsigned int button); /// - virtual bool InsertInset(BufferView *, Inset *) { return false; } + virtual void edit(BufferView *, bool front = true); + /// + virtual void draw(BufferView *, LyXFont const &, + int baseline, float & x, bool cleared) const; /// - virtual bool InsertInsetAllowed(Inset *) const { return true; } + virtual bool insertInset(BufferView *, Inset *) { return false; } /// - virtual UpdatableInset * GetLockingInset() { return this; } + virtual UpdatableInset * getLockingInset() const { + return const_cast(this); + } /// - virtual UpdatableInset * GetFirstLockingInsetOfType(Inset::Code c) - { return (c == LyxCode()) ? this : 0; } + virtual UpdatableInset * getFirstLockingInsetOfType(Inset::Code c) + { return (c == lyxCode()) ? this : 0; } /// - virtual unsigned int InsetInInsetY() { return 0; } + virtual unsigned int insetInInsetY() { return 0; } /// - virtual bool UpdateInsetInInset(BufferView *, Inset *) + virtual bool updateInsetInInset(BufferView *, Inset *) { return false; } /// - virtual bool LockInsetInInset(BufferView *, UpdatableInset *) + virtual bool lockInsetInInset(BufferView *, UpdatableInset *) { return false; } /// - virtual bool UnlockInsetInInset(BufferView *, UpdatableInset *, - bool /*lr*/ = false) + virtual bool unlockInsetInInset(BufferView *, UpdatableInset *, + bool /*lr*/ = false) { return false; } /// An updatable inset could handle lyx editing commands - virtual RESULT LocalDispatch(BufferView *, kb_action, string const &); + virtual RESULT localDispatch(BufferView *, kb_action, string const &); /// bool isCursorVisible() const { return cursor_visible_; } /// virtual int getMaxWidth(BufferView * bv, UpdatableInset const *) const; /// - int scroll(bool recursive=true) const { + int scroll(bool recursive = true) const { // We need this method to not clobber the real method in Inset return Inset::scroll(recursive); } /// - virtual bool ShowInsetDialog(BufferView *) const { return false; } + virtual bool showInsetDialog(BufferView *) const { return false; } /// - virtual void nodraw(bool b) { + virtual void nodraw(bool b) const { block_drawing_ = b; } /// virtual bool nodraw() const { return block_drawing_; } + /// + // needed for spellchecking text + /// + virtual bool allowSpellcheck() { return false; } + /// + virtual string const selectNextWordToSpellcheck(BufferView *, float & value) const; + /// + virtual void selectSelectedWord(BufferView *) { return; } + /// + virtual void toggleSelection(BufferView *, bool /*kill_selection*/) { + return; + } + /// + // needed for search/replace functionality + /// + virtual bool searchForward(BufferView *, string const &, + bool = true, bool = false); + /// + virtual bool searchBackward(BufferView *, string const &, + bool = true, bool = false); protected: /// @@ -397,6 +548,31 @@ private: /// mutable bool cursor_visible_; /// - bool block_drawing_; + mutable bool block_drawing_; }; + +inline +bool UpdatableInset::checkInsertChar(LyXFont &) +{ + return true; +} + +/** + * returns true if pointer argument is valid + * and points to an editable inset + */ +inline bool isEditableInset(Inset * i) +{ + return i && i->editable(); +} + +/** + * returns true if pointer argument is valid + * and points to a highly editable inset + */ +inline bool isHighlyEditableInset(Inset * i) +{ + return i && i->editable() == Inset::HIGHLY_EDITABLE; +} + #endif