// -*- C++ -*-
-/* This file is part of
- * ======================================================
- *
- * LyX, The Document Processor
- *
- * Copyright 1995-2001 the LyX Team.
+/**
+ * \file inset.h
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Alejandro Aguilar Sierra
+ * \author Jürgen Vigna
+ * \author Lars Gullik Bjønnes
+ * \author Matthias Ettrich
*
- * ====================================================== */
+ * Full author contact details are available in file CREDITS
+ */
#ifndef INSET_H
#define INSET_H
-#ifdef __GNUG__
-#pragma interface
-#endif
#include <vector>
#include "LString.h"
-#include <X11/Xlib.h>
-#include "commandtags.h"
#include "LColor.h"
+#include "insetbase.h"
+#include "frontends/mouse_state.h"
+#include "support/types.h"
class LyXFont;
class BufferView;
class LyXLex;
class Paragraph;
class LyXCursor;
+class FuncRequest;
+class WordLangTuple;
struct LaTeXFeatures;
+namespace grfx {
+ class PreviewLoader;
+}
/// Insets
-class Inset {
+class Inset : public InsetBase {
public:
/** This is not quite the correct place for this enum. I think
the correct would be to let each subclass of Inset declare
///
LABEL_CODE, // 10
///
- IGNORE_CODE,
+ NOTE_CODE,
///
ACCENT_CODE,
///
///
FLOAT_CODE,
///
+ WRAP_CODE,
+ ///
MINIPAGE_CODE,
///
SPECIALCHAR_CODE, // 25
///
FLOAT_LIST_CODE,
///
- INDEX_PRINT_CODE
+ INDEX_PRINT_CODE,
+ ///
+ OPTARG_CODE
};
///
///
HIGHLY_EDITABLE
};
-
+
+ ///
+ typedef InsetBase::dispatch_result RESULT;
+
///
Inset();
///
/// what appears in the minibuffer when opening
virtual string const editMessage() const;
///
- virtual void edit(BufferView *, int x, int y, unsigned int button);
+ virtual void edit(BufferView *, int x, int y, mouse_button::state button);
///
virtual void edit(BufferView *, bool front = true);
///
virtual EDITABLE editable() const;
- /// This is called when the user clicks inside an inset
- virtual void insetButtonPress(BufferView *, int, int, int) {}
- /// This is called when the user releases the button inside an inset
- // 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 RESULT localDispatch(FuncRequest const & cmd);
///
virtual bool isTextInset() const { return false; }
///
virtual bool doClearArea() const { return true; }
- ///
+ /// return true if the inset should be removed automatically
virtual bool autoDelete() const;
/// returns true the inset can hold an inset of given type
virtual bool insetAllowed(Inset::Code) const { return false; }
bool free_spc) const = 0;
///
virtual int ascii(Buffer const *,
- std::ostream &, int linelen = 0) const = 0;
+ std::ostream &, int linelen = 0) 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 &, bool) const = 0;
/// Updates needed features for this inset.
virtual void validate(LaTeXFeatures & features) const;
- ///
- virtual bool deletable() const;
-
+
/// returns LyX code associated with the inset. Used for TOC, ...)
virtual Inset::Code lyxCode() const { return NO_CODE; }
-
+
virtual std::vector<string> const getLabelList() const {
return std::vector<string>();
}
///
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;
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 {
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);
+ bool toggleall = false, bool selectall = false);
///
// needed for spellchecking text
///
- virtual bool allowSpellcheck() { return false; }
+ virtual bool allowSpellcheck() const { 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?
+ // is this equivalent to a space (which is BTW different from
+ // a line separator)?
virtual bool isSpace() const { return false; }
- // if this inset has paragraphs should they be outputed all as default
- // paragraps with "Standard" layout?
+ // 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;
+ /** returns true if, when outputing LaTeX, font changes should
+ be closed before generating this inset. This is needed for
+ insets that may contain several paragraphs */
+ virtual bool noFontChange() const { return false; }
+ //
+ virtual void getDrawFont(LyXFont &) 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;
+
+ /// mark the inset contents as erased (for change tracking)
+ virtual void markErased() {}
+
+ /** Adds a LaTeX snippet to the Preview Loader for transformation
+ * into a bitmap image. Does not start the laoding process.
+ *
+ * Most insets have no interest in this capability, so the method
+ * defaults to empty.
+ */
+ virtual void addPreview(grfx::PreviewLoader &) const {}
+
+ /** Find the PreviewLoader, add a LaTeX snippet to it and
+ * start the loading process.
+ *
+ * Most insets have no interest in this capability, so the method
+ * defaults to empty.
+ */
+ virtual void generatePreview() const {}
+
protected:
///
inline
bool Inset::insetAllowed(Inset * in) const
-{
- return insetAllowed(in->lyxCode());
+{
+ return insetAllowed(in->lyxCode());
}
// 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.
-// [Alejandro 080596]
+// [Alejandro 080596]
/** Extracted from Matthias notes:
- *
- * An inset can simple call LockInset in it's edit call and *ONLY*
+ *
+ * An inset can simple call LockInset in it's edit call and *ONLY*
* in it's edit call.
*
- * Unlocking is either done by LyX or the inset itself with a
+ * Unlocking is either done by LyX or the inset itself with a
* UnlockInset-call
*
* 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
* 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
- * UpdateInset(this).
- *
+ * updateInset(this).
+ *
* It's is completly irrelevant, where the inset is. UpdateInset will
- * find it in any paragraph in any buffer.
+ * find it in any paragraph in any buffer.
* Of course the_locking_inset and the insets in the current paragraph/buffer
* are checked first, so no performance problem should occur.
*/
class UpdatableInset : public Inset {
public:
- /** Dispatch result codes
- Now that nested updatable insets are allowed, the local dispatch
- becomes a bit complex, just two possible results (boolean)
- are not enough.
-
- 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
- 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_RIGHT,
- FINISHED_UP,
- FINISHED_DOWN
- };
-
- /// To convert old binary dispatch results
- RESULT DISPATCH_RESULT(bool b) {
- return b ? DISPATCHED : FINISHED;
- }
-
///
UpdatableInset();
///
virtual bool checkInsertChar(LyXFont &);
///
virtual EDITABLE editable() const;
-
- /// may call ToggleLockedInsetCursor
+
+ ///
virtual void toggleInsetCursor(BufferView *);
///
virtual void showInsetCursor(BufferView *, bool show = true);
///
virtual void getCursorPos(BufferView *, int &, int &) const {}
///
- virtual void insetButtonPress(BufferView *, int x, int y, int button);
- ///
- // 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 x, int y, int button);
- ///
- virtual void insetKeyPress(XKeyEvent * ev);
- ///
- virtual void insetMotionNotify(BufferView *, int x, int y, int state);
- ///
virtual void insetUnlock(BufferView *);
///
- virtual void edit(BufferView *, int x, int y, unsigned int button);
+ virtual void edit(BufferView *, int x, int y, mouse_button::state button);
///
virtual void edit(BufferView *, bool front = true);
///
virtual UpdatableInset * getFirstLockingInsetOfType(Inset::Code c)
{ return (c == lyxCode()) ? this : 0; }
///
- virtual unsigned int insetInInsetY() { return 0; }
+ virtual int insetInInsetY() const { return 0; }
///
virtual bool updateInsetInInset(BufferView *, Inset *)
{ return false; }
{ return false; }
///
virtual bool unlockInsetInInset(BufferView *, UpdatableInset *,
- bool /*lr*/ = false)
+ bool /*lr*/ = false)
{ return false; }
/// An updatable inset could handle lyx editing commands
- virtual RESULT localDispatch(BufferView *, kb_action, string const &);
+ virtual RESULT localDispatch(FuncRequest const & cmd);
///
bool isCursorVisible() const { return cursor_visible_; }
///
///
// needed for spellchecking text
///
- virtual bool allowSpellcheck() { return false; }
+ virtual bool allowSpellcheck() const { return false; }
///
- virtual string const selectNextWordToSpellcheck(BufferView *, float & value) const;
+ virtual WordLangTuple const
+ selectNextWordToSpellcheck(BufferView *, float & value) const;
///
- virtual void selectSelectedWord(BufferView *) { return; }
+ virtual void selectSelectedWord(BufferView *) {}
///
virtual void toggleSelection(BufferView *, bool /*kill_selection*/) {
return;
}
+
+ /// find the next change in the inset
+ virtual bool nextChange(BufferView * bv, lyx::pos_type & length);
+
///
// needed for search/replace functionality
///
virtual bool searchForward(BufferView *, string const &,
- bool const & = true, bool const & = false);
+ bool = true, bool = false);
///
virtual bool searchBackward(BufferView *, string const &,
- bool const & = true, bool const & = false);
+ bool = true, bool = false);
+
protected:
///
*/
inline bool isEditableInset(Inset * i)
{
- return i && i->editable();
+ return i && i->editable();
}
-
+
/**
* returns true if pointer argument is valid
* and points to a highly editable inset
projects / lyx.git / blobdiff