{
for (Buffer::inset_iterator it = buffer()->inset_iterator_begin();
it != buffer()->inset_iterator_end(); ++it) {
- vector<string> labels = it->getLabelList();
+ vector<string> labels;
+ it->getLabelList(labels);
if (find(labels.begin(),labels.end(),label)
!= labels.end()) {
beforeChange(text);
bool BufferView::ChangeRefsIfUnique(string const & from, string const & to)
{
// Check if the label 'from' appears more than once
- vector<string> labels = buffer()->getLabelList();
+ vector<string> labels;
+ buffer()->getLabelList(labels);
if (lyx::count(labels.begin(), labels.end(), from) > 1)
return false;
+2003-06-16 André Pönitz <poenitz@gmx.net>
+
+ * BufferView.C:
+ * buffer.C:
+ * buffer.h:
+ * paragraph.C:
+ * tabular.[Ch]: IU of clone() and getLabelList();
+
2003-06-13 André Pönitz <poenitz@gmx.net>
* tabular.h: compactification
}
-vector<string> const Buffer::getLabelList() const
+void Buffer::getLabelList(std::vector<string> & list) const
{
/// if this is a child document and the parent is already loaded
/// Use the parent's list instead [ale990407]
if (!params.parentname.empty()
&& bufferlist.exists(params.parentname)) {
Buffer const * tmp = bufferlist.getBuffer(params.parentname);
- if (tmp)
- return tmp->getLabelList();
+ if (tmp) {
+ tmp->getLabelList(list);
+ return;
+ }
}
- vector<string> label_list;
for (inset_iterator it = inset_const_iterator_begin();
it != inset_const_iterator_end(); ++it) {
- vector<string> const l = it->getLabelList();
- label_list.insert(label_list.end(), l.begin(), l.end());
+ it->getLabelList(list);
}
- return label_list;
}
/// return all bibkeys from buffer and its childs
void fillWithBibKeys(std::vector<std::pair<string, string> > & keys) const;
///
- std::vector<string> const getLabelList() const;
+ void getLabelList(std::vector<string> &) const;
/** This will clearly have to change later. Later we can have more
than one user per buffer. */
Buffer const * buf = bufferlist.getBuffer(MakeAbsPath(name));
if (!buf)
buf = kernel().buffer();
- return buf->getLabelList();
+ vector<string> list;
+ buf->getLabelList(list);
+ return list;
}
+2003-06-16 André Pönitz <poenitz@gmx.net>
+
+ * insetbase.h: new virtual base function clone()
+
+ * *inset*.[Ch]: IU of clone() and getLabelList (i.e. essentially
+ Inset * clone() -> InsetBase * clone()
+
2003-06-13 André Pönitz <poenitz@gmx.net>
* insettabular.[Ch]: make tabular a proper member
#ifndef INSET_H
#define INSET_H
-#include "LString.h"
#include "LColor.h"
#include "insetbase.h"
#include "support/types.h"
/// 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() const = 0;
-
/// returns true to override begin and end inset in file
virtual bool directWrite() const;
#ifndef INSETBASE_H
#define INSETBASE_H
+#include "LString.h"
+
#include <vector>
class BufferView;
/// type for column numbers
typedef size_t col_type;
+ /// virtual base class destructor
+ virtual ~InsetBase() {}
+ /// replicate ourselves
+ virtual InsetBase * clone() const = 0;
+
// the real dispatcher
virtual dispatch_result dispatch
(FuncRequest const & cmd, idx_type & idx, pos_type & pos);
/// draw inset and update (xo, yo)-cache
virtual void draw(PainterInfo & pi, int x, int y) const = 0;
- ///
- virtual ~InsetBase() {}
-
/// Methods to cache and retrieve a cached BufferView.
virtual void cache(BufferView *) const {}
///
virtual BufferView * view() const { return 0; }
/// request "external features"
virtual void validate(LaTeXFeatures &) const {}
+ /// fill in all labels in the inset
+ virtual void getLabelList(std::vector<string> &) const {}
};
#endif
}
-Inset * InsetBibitem::clone() const
+InsetBase * InsetBibitem::clone() const
{
InsetBibitem * b = new InsetBibitem(params());
b->setCounter(counter);
///
~InsetBibitem();
///
- Inset * clone() const;
+ InsetBase * clone() const;
///
virtual dispatch_result localDispatch(FuncRequest const & cmd);
/** Currently \bibitem is used as a LyX2.x command,
///
~InsetBibtex();
///
- Inset * clone() const {
+ InsetBase * clone() const {
return new InsetBibtex(params());
}
/// small wrapper for the time being
///
~InsetCitation();
///
- Inset * clone() const {
+ InsetBase * clone() const {
return new InsetCitation(params());
}
///
}
-vector<string> const InsetCollapsable::getLabelList() const
+void InsetCollapsable::getLabelList(std::vector<string> & list) const
{
- return inset.getLabelList();
+ inset.getLabelList(list);
}
///
void resizeLyXText(BufferView *, bool force = false) const;
///
- std::vector<string> const getLabelList() const;
+ void getLabelList(std::vector<string> &) const;
///
bool nodraw() const;
///
{}
-Inset * InsetEnvironment::clone() const
+InsetBase * InsetEnvironment::clone() const
{
return new InsetEnvironment(*this);
}
///
void read(Buffer const * buf, LyXLex & lex);
///
- Inset * clone() const;
+ InsetBase * clone() const;
///
Inset::Code lyxCode() const { return Inset::ENVIRONMENT_CODE; }
///
///
EDITABLE editable() const { return IS_EDITABLE; }
///
- Inset * clone() const {
+ InsetBase * clone() const {
return new InsetError(contents);
}
///
}
-Inset * InsetERT::clone() const
+InsetBase * InsetERT::clone() const
{
return new InsetERT(*this);
}
///
InsetERT(InsetERT const &);
///
- Inset * clone() const;
+ InsetBase * clone() const;
///
InsetERT(BufferParams const &,
Language const *, string const & contents, bool collapsed);
}
-Inset * InsetExternal::clone() const
+InsetBase * InsetExternal::clone() const
{
InsetExternal * inset = new InsetExternal(*this);
return inset;
virtual Inset::Code lyxCode() const { return EXTERNAL_CODE; }
///
- virtual Inset * clone() const;
+ virtual InsetBase * clone() const;
/// Set the inset parameters.
virtual void setParams(Params const &, string const & filepath);
}
-Inset * InsetFloat::clone() const
+InsetBase * InsetFloat::clone() const
{
return new InsetFloat(*this);
}
///
void validate(LaTeXFeatures & features) const;
///
- Inset * clone() const;
+ InsetBase * clone() const;
///
Inset::Code lyxCode() const { return Inset::FLOAT_CODE; }
///
///
~InsetFloatList();
///
- Inset * clone() const {
+ InsetBase * clone() const {
return new InsetFloatList(getCmdName());
}
///
}
-Inset * InsetFoot::clone() const
+InsetBase * InsetFoot::clone() const
{
return new InsetFoot(*this);
}
///
InsetFoot(InsetFoot const &);
///
- Inset * clone() const;
+ InsetBase * clone() const;
///
Inset::Code lyxCode() const { return Inset::FOOT_CODE; }
///
}
-Inset * InsetGraphics::clone() const
+InsetBase * InsetGraphics::clone() const
{
return new InsetGraphics(*this);
}
Inset::Code lyxCode() const { return Inset::GRAPHICS_CODE; }
///
- virtual Inset * clone() const;
+ virtual InsetBase * clone() const;
/** Set the inset parameters, used by the GUIndependent dialog.
Return true of new params are different from what was so far.
///
InsetHFill();
///
- virtual Inset * clone() const {
+ virtual InsetBase * clone() const {
return new InsetHFill;
}
///
}
-Inset * InsetInclude::clone() const
+InsetBase * InsetInclude::clone() const
{
//Params p(params_);
//p.masterFilename_ = buffer.fileName();
}
-vector<string> const InsetInclude::getLabelList() const
+void InsetInclude::getLabelList(std::vector<string> & list) const
{
- vector<string> l;
-
if (loadIfNeeded()) {
Buffer * tmp = bufferlist.getBuffer(getFileName());
tmp->setParentName("");
- l = tmp->getLabelList();
+ tmp->getLabelList(list);
tmp->setParentName(getMasterFilename());
}
-
- return l;
}
void set(Params const & params);
///
- virtual Inset * clone() const;
+ virtual InsetBase * clone() const;
///
Inset::Code lyxCode() const { return Inset::INCLUDE_CODE; }
/// This returns the list of labels on the child buffer
- std::vector<string> const getLabelList() const;
+ void getLabelList(std::vector<string> &) const;
/// This returns the list of bibkeys on the child buffer
void fillWithBibKeys(std::vector<std::pair<string,string> > & keys) const;
///
///
~InsetIndex();
///
- virtual Inset * clone() const {
+ virtual InsetBase * clone() const {
return new InsetIndex(params());
}
///
///
~InsetPrintIndex();
///
- Inset * clone() const {
+ InsetBase * clone() const {
return new InsetPrintIndex(params());
}
///
InsetLabel::~InsetLabel()
{
- InsetCommandMailer mailer("label", *this);
- mailer.hideDialog();
+ InsetCommandMailer("label", *this).hideDialog();
}
-vector<string> const InsetLabel::getLabelList() const
+void InsetLabel::getLabelList(std::vector<string> & list) const
{
- return vector<string>(1, getContents());
+ list.push_back(getContents());
}
///
~InsetLabel();
///
- virtual Inset * clone() const {
+ virtual InsetBase * clone() const {
return new InsetLabel(params());
}
///
///
Inset::Code lyxCode() const { return Inset::LABEL_CODE; }
///
- std::vector<string> const getLabelList() const;
+ void getLabelList(std::vector<string> &) const;
///
int latex(Buffer const *, std::ostream &,
LatexRunParams const &) const;
}
-Inset * InsetLatexAccent::clone() const
+InsetBase * InsetLatexAccent::clone() const
{
return new InsetLatexAccent(contents);
}
///
bool directWrite() const;
///
- virtual Inset * clone() const;
+ virtual InsetBase * clone() const;
///
Inset::Code lyxCode()const;
///
}
-Inset * InsetMarginal::clone() const
+InsetBase * InsetMarginal::clone() const
{
return new InsetMarginal(*this);
}
///
InsetMarginal(InsetMarginal const &);
///
- Inset * clone() const;
+ InsetBase * clone() const;
///
Inset::Code lyxCode() const { return Inset::MARGIN_CODE; }
///
{}
-Inset * InsetMinipage::clone() const
+InsetBase * InsetMinipage::clone() const
{
return new InsetMinipage(*this);
}
///
void read(Buffer const * buf, LyXLex & lex);
///
- Inset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo &, Dimension &) const;
///
InsetNewline() {}
- virtual Inset * clone() const {
+ virtual InsetBase * clone() const {
return new InsetNewline;
}
}
-Inset * InsetNote::clone() const
+InsetBase * InsetNote::clone() const
{
return new InsetNote(*this);
}
///
InsetNote(InsetNote const &);
///
- Inset * clone() const;
+ InsetBase * clone() const;
///
string const editMessage() const;
///
}
-Inset * InsetOptArg::clone() const
+InsetBase * InsetOptArg::clone() const
{
return new InsetOptArg(*this);
}
InsetOptArg(InsetOptArg const &);
/// make a duplicate of this inset
- Inset * clone() const;
+ InsetBase * clone() const;
/// this inset is editable
EDITABLE editable() const { return IS_EDITABLE; }
/// code of the inset
}
-Inset * InsetQuotes::clone() const
+InsetBase * InsetQuotes::clone() const
{
return new InsetQuotes(language_, side_, times_);
}
/// Create the right quote inset after character c
InsetQuotes(char c, BufferParams const & params);
///
- Inset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo &, Dimension &) const;
///
~InsetRef();
///
- virtual Inset * clone() const {
+ virtual InsetBase * clone() const {
return new InsetRef(*this);
}
///
}
-Inset * InsetSpace::clone() const
+InsetBase * InsetSpace::clone() const
{
return new InsetSpace(kind_);
}
///
int docbook(Buffer const *, std::ostream &, bool mixcont) const;
///
- virtual Inset * clone() const;
+ virtual InsetBase * clone() const;
///
Inset::Code lyxCode() const { return Inset::SPACE_CODE; }
/// We don't need \begin_inset and \end_inset
}
-Inset * InsetSpecialChar::clone() const
+InsetBase * InsetSpecialChar::clone() const
{
return new InsetSpecialChar(kind_);
}
///
int docbook(Buffer const *, std::ostream &, bool mixcont) const;
///
- virtual Inset * clone() const;
+ virtual InsetBase * clone() const;
///
Inset::Code lyxCode() const { return Inset::SPECIALCHAR_CODE; }
/// We don't need \begin_inset and \end_inset
}
-Inset * InsetTabular::clone() const
+InsetBase * InsetTabular::clone() const
{
return new InsetTabular(*this);
}
}
-vector<string> const InsetTabular::getLabelList() const
+void InsetTabular::getLabelList(std::vector<string> & list) const
{
- return tabular.getLabelList();
+ tabular.getLabelList(list);
}
///
~InsetTabular();
///
- Inset * clone() const;
+ InsetBase * clone() const;
///
void read(Buffer const *, LyXLex &);
///
///
FuncStatus getStatus(string const & argument) const;
///
- std::vector<string> const getLabelList() const;
+ void getLabelList(std::vector<string> &) const;
///
void nodraw(bool b) const {
UpdatableInset::nodraw(b);
}
-InsetText::~InsetText()
-{
- paragraphs.clear();
-}
-
-
void InsetText::clear(bool just_mark_erased)
{
if (just_mark_erased) {
}
-Inset * InsetText::clone() const
+InsetBase * InsetText::clone() const
{
return new InsetText(*this);
}
}
-vector<string> const InsetText::getLabelList() const
+void InsetText::getLabelList(std::vector<string> & list) const
{
- vector<string> label_list;
-
ParagraphList::const_iterator pit = paragraphs.begin();
ParagraphList::const_iterator pend = paragraphs.end();
for (; pit != pend; ++pit) {
InsetList::const_iterator beg = pit->insetlist.begin();
InsetList::const_iterator end = pit->insetlist.end();
- for (; beg != end; ++beg) {
- vector<string> const l = beg->inset->getLabelList();
- label_list.insert(label_list.end(), l.begin(), l.end());
- }
+ for (; beg != end; ++beg)
+ beg->inset->getLabelList(list);
}
- return label_list;
}
///
InsetText(BufferParams const &);
///
- explicit
- InsetText(InsetText const &);
+ explicit InsetText(InsetText const &);
///
- ~InsetText();
- ///
- Inset * clone() const;
+ InsetBase * clone() const;
///
InsetText & operator=(InsetText const & it);
/// empty inset to empty par, or just mark as erased
///
bool showInsetDialog(BufferView *) const;
///
- std::vector<string> const getLabelList() const;
+ void getLabelList(std::vector<string> &) const;
///
bool nodraw() const;
///
}
-Inset * InsetTheorem::clone() const
+InsetBase * InsetTheorem::clone() const
{
#ifdef WITH_WARNINGS
#warning Is this inset used? If YES this is WRONG!!! (Jug)
///
void write(Buffer const * buf, std::ostream & os) const;
///
- virtual Inset * clone() const;
+ virtual InsetBase * clone() const;
///
Inset::Code lyxCode() const { return Inset::THEOREM_CODE; }
///
///
~InsetTOC();
///
- virtual Inset * clone() const {
+ virtual InsetBase * clone() const {
return new InsetTOC(params());
}
///
///
~InsetUrl();
///
- virtual Inset * clone() const {
+ virtual InsetBase * clone() const {
return new InsetUrl(params());
}
///
}
-Inset * InsetWrap::clone() const
+InsetBase * InsetWrap::clone() const
{
return new InsetWrap(*this);
}
///
void validate(LaTeXFeatures & features) const;
///
- Inset * clone() const;
+ InsetBase * clone() const;
///
Inset::Code lyxCode() const { return Inset::WRAP_CODE; }
///
-2003-06-11 Angus Leeming <leeming@lyx.org>
- * button_inset.[Ch]: removed.
- * Makefile.am: remove button_inset.[Ch].
+2003-06-16 André Pönitz <poenitz@gmx.net>
- * command_inset.[Ch]: no longer derived from ButtonInset.
- Instead has a ButtonRenderer member variable.
+ * math_*inset.[Ch]: IU of clone()
- * ref_inset.[Ch]: associated changes.
-
-2003-06-03 John Levon <levon@movementarian.org>
-
- * formula.[Ch]:
- * formulabase.h:
- * formulamacro.[Ch]: clone() doesn't take a Buffer anymore
-
-2003-06-02 André Pönitz <poenitz@gmx.net>
-
- * math_*.[Ch]: finish unified two-stage drawing
-
- * math_inset.h: move validate to insetbase.h
+ * math_cursorpos.[Ch]:
+ * math_cursor.[Ch]: rename MathCursorPos -> CursorPos, par_ -> inset_
2003-05-28 André Pönitz <poenitz@gmx.net>
}
-MathInset * CommandInset::clone() const
+InsetBase * CommandInset::clone() const
{
return new CommandInset(*this);
}
///
explicit CommandInset(string const & name);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
// this whole function is a hack and won't work for incremental font
// changes...
bv->lockedInsetStoreUndo(Undo::EDIT);
- if (mathcursor->par()->name() == font)
+ if (mathcursor->inset()->name() == font)
mathcursor->handleFont(font);
else {
mathcursor->handleNest(createMathInset(font));
{}
-MathInset * MathAMSArrayInset::clone() const
+InsetBase * MathAMSArrayInset::clone() const
{
return new MathAMSArrayInset(*this);
}
///
MathAMSArrayInset(string const & name);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
}
-MathInset * MathArrayInset::clone() const
+InsetBase * MathArrayInset::clone() const
{
return new MathArrayInset(*this);
}
/// convienience constructor from whitespace/newline seperated data
MathArrayInset(string const &, string const & str);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
#include <config.h>
-
#include "math_atom.h"
#include "math_inset.h"
+#include "insets/insetbase.h"
#include <utility>
{}
-MathAtom::MathAtom(MathInset * p)
- : nucleus_(p)
+MathAtom::MathAtom(InsetBase * p)
+ : nucleus_(static_cast<MathInset *>(p))
{}
MathAtom::MathAtom(MathAtom const & at)
- : nucleus_(at.nucleus_ ? at.nucleus_->clone() : 0)
+ : nucleus_(at.nucleus_ ? static_cast<MathInset *>(at.nucleus_->clone()) : 0)
{}
*/
+class InsetBase;
class MathInset;
class MathAtom {
// std::containers
MathAtom();
/// the "real constructor"
- explicit MathAtom(MathInset * p);
+ explicit MathAtom(InsetBase * p);
/// copy constructor, invokes nucleus_->clone()
MathAtom(MathAtom const &);
/// we really need to clean up
{}
-MathInset * MathBigInset::clone() const
+InsetBase * MathBigInset::clone() const
{
return new MathBigInset(*this);
}
///
MathBigInset(string const & name, string const & delim);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathBinaryOpInset::clone() const
+InsetBase * MathBinaryOpInset::clone() const
{
return new MathBinaryOpInset(*this);
}
///
explicit MathBinaryOpInset(char op);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void draw(PainterInfo &, int x, int y) const;
///
{}
-MathInset * MathBinomInset::clone() const
+InsetBase * MathBinomInset::clone() const
{
return new MathBinomInset(*this);
}
///
explicit MathBinomInset(bool choose = false);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void write(WriteStream & os) const;
///
{}
-MathInset * MathBoxInset::clone() const
+InsetBase * MathBoxInset::clone() const
{
return new MathBoxInset(*this);
}
///
explicit MathBoxInset(string const & name);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
mode_type currentMode() const { return TEXT_MODE; }
///
}
-MathInset * MathBraceInset::clone() const
+InsetBase * MathBraceInset::clone() const
{
return new MathBraceInset(*this);
}
///
MathBraceInset(MathArray const & ar);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
/// we write extra braces in any case...
bool extraBraces() const { return true; }
///
{}
-MathInset * MathCasesInset::clone() const
+InsetBase * MathCasesInset::clone() const
{
return new MathCasesInset(*this);
}
///
explicit MathCasesInset(row_type rows = 1u);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
-MathInset * MathCharInset::clone() const
+InsetBase * MathCharInset::clone() const
{
return new MathCharInset(*this);
}
///
explicit MathCharInset(char c);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
}
-MathInset * MathCommentInset::clone() const
+InsetBase * MathCommentInset::clone() const
{
return new MathCommentInset(*this);
}
///
explicit MathCommentInset(string const &);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
void MathCursor::push(MathAtom & t)
{
- Cursor_.push_back(MathCursorPos(t.nucleus()));
+ Cursor_.push_back(CursorPos(t.nucleus()));
}
//lyxerr << "Leaving atom to the left\n";
if (depth() <= 1) {
if (depth() == 1)
- par()->notifyCursorLeaves(idx());
+ inset()->notifyCursorLeaves(idx());
return false;
}
- par()->notifyCursorLeaves(idx());
+ inset()->notifyCursorLeaves(idx());
Cursor_.pop_back();
return true;
}
bool MathCursor::popRight()
{
- //lyxerr << "Leaving atom "; par()->write(cerr, false); cerr << " right\n";
+ //lyxerr << "Leaving atom "; inset()->write(cerr, false); cerr << " right\n";
if (depth() <= 1) {
if (depth() == 1)
- par()->notifyCursorLeaves(idx());
+ inset()->notifyCursorLeaves(idx());
return false;
}
- par()->notifyCursorLeaves(idx());
+ inset()->notifyCursorLeaves(idx());
Cursor_.pop_back();
posRight();
return true;
bool MathCursor::isInside(MathInset const * p) const
{
for (unsigned i = 0; i < depth(); ++i)
- if (Cursor_[i].par_ == p)
+ if (Cursor_[i].inset_ == p)
return true;
return false;
}
// we can't move into anything new during selection
if (depth() == Anchor_.size())
return false;
- if (t.operator->() != Anchor_[depth()].par_)
+ if (t.operator->() != Anchor_[depth()].inset_)
return false;
}
return true;
bool MathCursor::inNucleus() const
{
- return par()->asScriptInset() && idx() == 2;
+ return inset()->asScriptInset() && idx() == 2;
}
{
Cursor_.clear();
push(formula_->par());
- par()->idxFirst(idx(), pos());
+ inset()->idxFirst(idx(), pos());
}
{
Cursor_.clear();
push(formula_->par());
- par()->idxLast(idx(), pos());
+ inset()->idxLast(idx(), pos());
}
// anchor might be deeper, should have same path then
for (MathIterator::size_type i = 0; i < cursor.size(); ++i)
- if (cursor[i].par_ != anchor[i].par_)
+ if (cursor[i].inset_ != anchor[i].inset_)
return false;
// position should be ok.
autocorrect_ = false;
selHandle(sel);
macroModeClose();
- if (!par()->idxHome(idx(), pos()))
+ if (!inset()->idxHome(idx(), pos()))
return popLeft();
dump("home 2");
targetx_ = -1; // "no target"
autocorrect_ = false;
selHandle(sel);
macroModeClose();
- if (!par()->idxEnd(idx(), pos()))
+ if (!inset()->idxEnd(idx(), pos()))
return popRight();
dump("end 2");
targetx_ = -1; // "no target"
}
if (pos() == 0) {
- if (par()->ncols() == 1 &&
- par()->nrows() == 1 &&
+ if (inset()->ncols() == 1 &&
+ inset()->nrows() == 1 &&
depth() == 1 &&
size() == 0)
return false;
// delete empty cells if possible
if (array().empty())
- if (par()->idxDelete(idx()))
+ if (inset()->idxDelete(idx()))
return true;
// old behaviour when in last position of cell
if (pos() == size()) {
- if (par()->ncols() == 1 && par()->nrows() == 1 && depth() == 1 && size() == 0)
+ if (inset()->ncols() == 1 && inset()->nrows() == 1 && depth() == 1 && size() == 0)
return false;
else{
- par()->idxGlue(idx());
+ inset()->idxGlue(idx());
return true;
}
}
{
if (!selection_)
return;
- MathCursorPos i1;
- MathCursorPos i2;
+ CursorPos i1;
+ CursorPos i2;
getSelection(i1, i2);
- i1.par_->drawSelection(pi, i1.idx_, i1.pos_, i2.idx_, i2.pos_);
+ i1.inset_->drawSelection(pi, i1.idx_, i1.pos_, i2.idx_, i2.pos_);
}
void MathCursor::getPos(int & x, int & y) const
{
- par()->getPos(idx(), pos(), x, y);
+ inset()->getPos(idx(), pos(), x, y);
}
}
-MathInset * MathCursor::par() const
+MathInset * MathCursor::inset() const
{
- return cursor().par_;
+ return cursor().inset_;
}
MathGridInset * MathCursor::enclosingGrid(MathCursor::idx_type & idx) const
{
for (MathInset::difference_type i = depth() - 1; i >= 0; --i) {
- MathGridInset * p = Cursor_[i].par_->asGridInset();
+ MathGridInset * p = Cursor_[i].inset_->asGridInset();
if (p) {
idx = Cursor_[i].idx_;
return p;
void MathCursor::popToHere(MathInset const * p)
{
- while (depth() && Cursor_.back().par_ != p)
+ while (depth() && Cursor_.back().inset_ != p)
Cursor_.pop_back();
}
void MathCursor::popToEnclosingGrid()
{
- while (depth() && !Cursor_.back().par_->asGridInset())
+ while (depth() && !Cursor_.back().inset_->asGridInset())
Cursor_.pop_back();
}
void MathCursor::popToEnclosingHull()
{
- while (depth() && !Cursor_.back().par_->asHullInset())
+ while (depth() && !Cursor_.back().inset_->asHullInset())
Cursor_.pop_back();
}
void MathCursor::normalize()
{
- if (idx() >= par()->nargs()) {
+ if (idx() >= inset()->nargs()) {
lyxerr << "this should not really happen - 1: "
- << idx() << ' ' << par()->nargs()
- << " in: " << par() << endl;
+ << idx() << ' ' << inset()->nargs()
+ << " in: " << inset() << endl;
dump("error 2");
}
- idx() = min(idx(), par()->nargs() - 1);
+ idx() = min(idx(), inset()->nargs() - 1);
if (pos() > size()) {
lyxerr << "this should not really happen - 2: "
<< pos() << ' ' << size() << " in idx: " << idx()
<< " in atom: '";
WriteStream wi(lyxerr, false, true);
- par()->write(wi);
+ inset()->write(wi);
lyxerr << endl;
dump("error 4");
}
{
static MathArray dummy;
- if (idx() >= par()->nargs()) {
+ if (idx() >= inset()->nargs()) {
lyxerr << "############ idx_ " << idx() << " not valid\n";
return dummy;
}
void MathCursor::idxNext()
{
- par()->idxNext(idx(), pos());
+ inset()->idxNext(idx(), pos());
}
void MathCursor::idxPrev()
{
- par()->idxPrev(idx(), pos());
+ inset()->idxPrev(idx(), pos());
}
}
-void MathCursor::getSelection(MathCursorPos & i1, MathCursorPos & i2) const
+void MathCursor::getSelection(CursorPos & i1, CursorPos & i2) const
{
- MathCursorPos anc = normalAnchor();
+ CursorPos anc = normalAnchor();
if (anc < cursor()) {
i1 = anc;
i2 = cursor();
}
-MathCursorPos & MathCursor::cursor()
+CursorPos & MathCursor::cursor()
{
lyx::Assert(depth());
return Cursor_.back();
}
-MathCursorPos const & MathCursor::cursor() const
+CursorPos const & MathCursor::cursor() const
{
lyx::Assert(depth());
return Cursor_.back();
}
// try current cell for e.g. text insets
- if (par()->idxUpDown2(idx(), pos(), up, targetx_))
+ if (inset()->idxUpDown2(idx(), pos(), up, targetx_))
return true;
//xarray().boundingBox(xlow, xhigh, ylow, yhigh);
// try to find an inset that knows better then we
while (1) {
- ///lyxerr << "updown: We are in " << *par() << " idx: " << idx() << '\n';
+ ///lyxerr << "updown: We are in " << *inset() << " idx: " << idx() << '\n';
// ask inset first
- if (par()->idxUpDown(idx(), pos(), up, targetx_)) {
+ if (inset()->idxUpDown(idx(), pos(), up, targetx_)) {
// try to find best position within this inset
if (!selection())
bruteFind2(xo, yo);
bool MathCursor::idxLineLast()
{
- idx() -= idx() % par()->ncols();
- idx() += par()->ncols() - 1;
+ idx() -= idx() % inset()->ncols();
+ idx() += inset()->ncols() - 1;
pos() = size();
return true;
}
bool MathCursor::idxLeft()
{
- return par()->idxLeft(idx(), pos());
+ return inset()->idxLeft(idx(), pos());
}
bool MathCursor::idxRight()
{
- return par()->idxRight(idx(), pos());
+ return inset()->idxRight(idx(), pos());
}
string safe = grabAndEraseSelection();
if (inNucleus()) {
// we are in a nucleus of a script inset, move to _our_ script
- par()->asScriptInset()->ensure(up);
+ inset()->asScriptInset()->ensure(up);
idx() = up;
pos() = 0;
} else if (hasPrevAtom() && prevAtom()->asScriptInset()) {
ostringstream os;
os << "Math editor mode. ";
for (int i = 0, n = depth(); i < n; ++i) {
- Cursor_[i].par_->infoize(os);
+ Cursor_[i].inset_->infoize(os);
os << " ";
}
if (hasPrevAtom())
namespace {
-void region(MathCursorPos const & i1, MathCursorPos const & i2,
+void region(CursorPos const & i1, CursorPos const & i2,
MathInset::row_type & r1, MathInset::row_type & r2,
MathInset::col_type & c1, MathInset::col_type & c2)
{
- MathInset * p = i1.par_;
+ MathInset * p = i1.inset_;
c1 = p->col(i1.idx_);
c2 = p->col(i2.idx_);
if (c1 > c2)
if (!selection_)
return string();
- MathCursorPos i1;
- MathCursorPos i2;
+ CursorPos i1;
+ CursorPos i2;
getSelection(i1, i2);
if (i1.idx_ == i2.idx_) {
for (col_type col = c1; col <= c2; ++col) {
if (col > c1)
data += '&';
- data += asString(i1.par_->cell(i1.par_->index(row, col)));
+ data += asString(i1.inset_->cell(i1.inset_->index(row, col)));
}
}
return data;
void MathCursor::eraseSelection()
{
- MathCursorPos i1;
- MathCursorPos i2;
+ CursorPos i1;
+ CursorPos i2;
getSelection(i1, i2);
if (i1.idx_ == i2.idx_)
i1.cell().erase(i1.pos_, i2.pos_);
else {
- MathInset * p = i1.par_;
+ MathInset * p = i1.inset_;
row_type r1, r2;
col_type c1, c2;
region(i1, i2, r1, r2, c1, c2);
}
-MathCursorPos MathCursor::normalAnchor() const
+CursorPos MathCursor::normalAnchor() const
{
if (Anchor_.size() < depth()) {
Anchor_ = Cursor_;
}
//lyx::Assert(Anchor_.size() >= cursor.depth());
// use Anchor on the same level as Cursor
- MathCursorPos normal = Anchor_[depth() - 1];
+ CursorPos normal = Anchor_[depth() - 1];
if (depth() < Anchor_.size() && !(normal < cursor())) {
// anchor is behind cursor -> move anchor behind the inset
++normal.pos_;
case LFUN_MOUSE_MOTION:
case LFUN_MOUSE_RELEASE:
case LFUN_MOUSE_DOUBLE: {
- MathCursorPos & pos = Cursor_.back();
+ CursorPos & pos = Cursor_.back();
dispatch_result res = UNDISPATCHED;
int x = 0, y = 0;
getPos(x, y);
}
for (int i = Cursor_.size() - 1; i >= 0; --i) {
- MathCursorPos & pos = Cursor_[i];
- dispatch_result res = pos.par_->dispatch(cmd, pos.idx_, pos.pos_);
+ CursorPos & pos = Cursor_[i];
+ dispatch_result res = pos.inset_->dispatch(cmd, pos.idx_, pos.pos_);
if (res != UNDISPATCHED) {
if (res == DISPATCHED_POP) {
Cursor_.shrink(i + 1);
MathInset::mode_type MathCursor::currentMode() const
{
for (int i = Cursor_.size() - 1; i >= 0; --i) {
- MathInset::mode_type res = Cursor_[i].par_->currentMode();
+ MathInset::mode_type res = Cursor_[i].inset_->currentMode();
if (res != MathInset::UNDECIDED_MODE)
return res;
}
[Have a look at math_inset.h first]
The MathCursor is different from the kind of cursor used in the Outer
-World. It contains a stack of MathCursorPos, each of which is made
+World. It contains a stack of CursorPos, each of which is made
up of a inset pointer, an index and a position offset, marking a path from
this formula's MathHullInset to the current position.
/// in pixels from left of screen
int targetX() const;
/// current inset
- MathInset * par() const;
+ MathInset * inset() const;
/// return the next enclosing grid inset and the cursor's index in it
MathGridInset * enclosingGrid(idx_type & idx) const;
/// go up to enclosing grid
MathAtom & nextAtom();
/// returns the selection
- void getSelection(MathCursorPos &, MathCursorPos &) const;
+ void getSelection(CursorPos &, CursorPos &) const;
/// returns the normalized anchor of the selection
- MathCursorPos normalAnchor() const;
+ CursorPos normalAnchor() const;
/// reference to the last item of the path, i.e. "The Cursor"
- MathCursorPos & cursor();
+ CursorPos & cursor();
/// reference to the last item of the path, i.e. "The Cursor"
- MathCursorPos const & cursor() const;
+ CursorPos const & cursor() const;
/// how deep are we nested?
unsigned depth() const;
{}
-MathInset * MathDecorationInset::clone() const
+InsetBase * MathDecorationInset::clone() const
{
return new MathDecorationInset(*this);
}
///
explicit MathDecorationInset(latexkeys const * key);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void draw(PainterInfo &, int x, int y) const;
///
}
-MathInset * MathDelimInset::clone() const
+InsetBase * MathDelimInset::clone() const
{
return new MathDelimInset(*this);
}
///
MathDelimInset(string const & left, string const & right, MathArray const &);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
MathDelimInset * asDelimInset() { return this; }
///
{}
-MathInset * MathDiffInset::clone() const
+InsetBase * MathDiffInset::clone() const
{
return new MathDiffInset(*this);
}
///
explicit MathDiffInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void addDer(MathArray const & der);
///
{}
-MathInset * MathDotsInset::clone() const
+InsetBase * MathDotsInset::clone() const
{
return new MathDotsInset(*this);
}
///
explicit MathDotsInset(latexkeys const * l);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathEnvInset::clone() const
+InsetBase * MathEnvInset::clone() const
{
return new MathEnvInset(*this);
}
///
MathEnvInset(string const & name_);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void draw(PainterInfo &, int x, int y) const;
///
#include "support/LOstream.h"
-MathInset * MathErtInset::clone() const
+InsetBase * MathErtInset::clone() const
{
return new MathErtInset(*this);
}
///
MathErtInset() {}
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
mode_type currentMode() const { return TEXT_MODE; }
///
}
-MathInset * MathExFuncInset::clone() const
+InsetBase * MathExFuncInset::clone() const
{
return new MathExFuncInset(*this);
}
///
MathExFuncInset(string const & name, MathArray const & ar);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
// 3 - upper
-MathInset * MathExIntInset::clone() const
+InsetBase * MathExIntInset::clone() const
{
return new MathExIntInset(*this);
}
///
explicit MathExIntInset(string const & name_);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void symbol(string const &);
///
{}
-MathInset * MathFboxInset::clone() const
+InsetBase * MathFboxInset::clone() const
{
return new MathFboxInset(*this);
}
///
MathFboxInset(latexkeys const * key);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
mode_type currentMode() const;
///
{}
-MathInset * MathFontInset::clone() const
+InsetBase * MathFontInset::clone() const
{
return new MathFontInset(*this);
}
///
explicit MathFontInset(latexkeys const * key);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
MathFontInset * asFontInset() { return this; }
///
}
-MathInset * MathFontOldInset::clone() const
+InsetBase * MathFontOldInset::clone() const
{
return new MathFontOldInset(*this);
}
///
explicit MathFontOldInset(latexkeys const * key);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
/// we are in text mode.
mode_type currentMode() const { return TEXT_MODE; }
/// we write extra braces in any case...
{}
-MathInset * MathFracInset::clone() const
+InsetBase * MathFracInset::clone() const
{
return new MathFracInset(*this);
}
///
explicit MathFracInset(bool atop = false);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathFrameboxInset::clone() const
+InsetBase * MathFrameboxInset::clone() const
{
return new MathFrameboxInset(*this);
}
///
MathFrameboxInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
}
-MathInset * MathGridInset::clone() const
+InsetBase * MathGridInset::clone() const
{
return new MathGridInset(*this);
}
/// Ensures that the dialog is closed.
~MathGridInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi) const;
///
}
-MathInset * MathHullInset::clone() const
+InsetBase * MathHullInset::clone() const
{
return new MathHullInset(*this);
}
///
explicit MathHullInset(string const & type);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
mode_type currentMode() const;
///
{}
-MathInset * MathInferInset::clone() const
+InsetBase * MathInferInset::clone() const
{
return new MathInferInset(*this);
}
///
explicit MathInferInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
/// our members behave nicely...
MathInset() {}
- /// reproduce itself
- virtual MathInset * clone() const = 0;
/// substitutes macro arguments if necessary
virtual void substitute(MathMacro const & macro);
/// draw selection between two positions
/// dump content to stderr for debugging
virtual void dump() const;
- /// LyXInset stuff
- /// write labels into a list
- virtual void getLabelList(std::vector<string> &) const {}
/// LyXInset stuff
virtual bool numberedType() const { return false; }
/// hull type
}
-MathInset const * MathIterator::par() const
+MathInset const * MathIterator::inset() const
{
- return back().par_;
+ return back().inset_;
}
-MathInset * MathIterator::par()
+MathInset * MathIterator::inset()
{
- return back().par_;
+ return back().inset_;
}
MathArray const & MathIterator::cell() const
{
- MathCursorPos const & top = back();
- return top.par_->cell(top.idx_);
+ CursorPos const & top = back();
+ return top.inset_->cell(top.idx_);
}
void MathIterator::push(MathInset * p)
{
//lyxerr << "push: " << p << endl;
- push_back(MathCursorPos(p));
+ push_back(CursorPos(p));
}
}
-MathCursorPos const & MathIterator::operator*() const
+CursorPos const & MathIterator::operator*() const
{
return back();
}
-MathCursorPos const & MathIterator::operator->() const
+CursorPos const & MathIterator::operator->() const
{
return back();
}
void MathIterator::goEnd()
{
- MathCursorPos & top = back();
- top.idx_ = top.par_->nargs() - 1;
+ CursorPos & top = back();
+ top.idx_ = top.inset_->nargs() - 1;
top.pos_ = cell().size();
}
void MathIterator::operator++()
{
- MathCursorPos & top = back();
- MathArray & ar = top.par_->cell(top.idx_);
+ CursorPos & top = back();
+ MathArray & ar = top.inset_->cell(top.idx_);
// move into the current inset if possible
// it is impossible for pos() == size()!
}
// otherwise try to move on one cell if possible
- while (top.idx_ + 1 < top.par_->nargs()) {
+ while (top.idx_ + 1 < top.inset_->nargs()) {
// idx() == nargs() is _not_ valid!
++top.idx_;
- if (top.par_->validCell(top.idx_)) {
+ if (top.inset_->validCell(top.idx_)) {
top.pos_ = 0;
return;
}
#ifndef MATH_ITERATOR_H
#define MATH_ITERATOR_H
-
#include "math_pos.h"
+
#include <vector>
+
// this is used for traversing math insets
-class MathIterator : private std::vector<MathCursorPos> {
+class MathIterator : private std::vector<CursorPos> {
public:
// re-use inherited stuff
- typedef std::vector<MathCursorPos> base_type;
+ typedef std::vector<CursorPos> base_type;
using base_type::clear;
using base_type::size;
using base_type::push_back;
/// start with given inset
explicit MathIterator(MathInset * p);
///
- MathCursorPos const & operator*() const;
+ CursorPos const & operator*() const;
///
- MathCursorPos const & operator->() const;
+ CursorPos const & operator->() const;
/// move on one step
void operator++();
/// move on several steps
void jump(difference_type);
/// read access to top most inset
- MathInset const * par() const;
+ MathInset const * inset() const;
/// read access to top most inset
- MathInset * par();
+ MathInset * inset();
/// helper for iend
void goEnd();
/// read access to top most item
{}
-MathInset * MathKernInset::clone() const
+InsetBase * MathKernInset::clone() const
{
return new MathKernInset(*this);
}
///
explicit MathKernInset(string const & wid);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathLefteqnInset::clone() const
+InsetBase * MathLefteqnInset::clone() const
{
return new MathLefteqnInset(*this);
}
///
MathLefteqnInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
string name() const;
///
}
-MathInset * MathLimInset::clone() const
+InsetBase * MathLimInset::clone() const
{
return new MathLimInset(*this);
}
///
MathLimInset(MathArray const & f, MathArray const & x, MathArray const & x0);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
-MathInset * MathMacro::clone() const
+InsetBase * MathMacro::clone() const
{
return new MathMacro(*this);
}
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void dump() const;
}
-MathInset * MathMacroArgument::clone() const
+InsetBase * MathMacroArgument::clone() const
{
return new MathMacroArgument(*this);
}
///
explicit MathMacroArgument(int);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
bool isActive() const { return false; }
///
}
-MathInset * MathMacroTemplate::clone() const
+InsetBase * MathMacroTemplate::clone() const
{
//lyxerr << "cloning MacroTemplate!\n";
return new MathMacroTemplate(*this);
///
explicit MathMacroTemplate(std::istream & is);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void write(WriteStream & os) const;
/// Number of arguments
{}
-MathInset * MathMakeboxInset::clone() const
+InsetBase * MathMakeboxInset::clone() const
{
return new MathMakeboxInset(*this);
}
///
MathMakeboxInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathMatrixInset::clone() const
+InsetBase * MathMatrixInset::clone() const
{
return new MathMatrixInset(*this);
}
///
MathMatrixInset(string const & str);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
/// identifies MatrixInsets
MathMatrixInset const * asMatrixInset() const { return this; }
{}
-MathInset * MathNumberInset::clone() const
+InsetBase * MathNumberInset::clone() const
{
return new MathNumberInset(*this);
}
///
explicit MathNumberInset(string const & s);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
}
-MathInset * MathParboxInset::clone() const
+InsetBase * MathParboxInset::clone() const
{
return new MathParboxInset(*this);
}
///
MathParboxInset * asParboxInset() { return this; }
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
mode_type currentMode() const { return TEXT_MODE; }
///
#include "support/LOstream.h"
-MathCursorPos::MathCursorPos()
- : par_(0), idx_(0), pos_(0)
+CursorPos::CursorPos()
+ : inset_(0), idx_(0), pos_(0)
{}
-MathCursorPos::MathCursorPos(MathInset * p)
- : par_(p), idx_(0), pos_(0)
+CursorPos::CursorPos(MathInset * p)
+ : inset_(p), idx_(0), pos_(0)
{
- lyx::Assert(par_);
+ lyx::Assert(inset_);
}
-MathArray & MathCursorPos::cell(MathArray::idx_type idx) const
+MathArray & CursorPos::cell(MathArray::idx_type idx) const
{
- lyx::Assert(par_);
- return par_->cell(idx);
+ lyx::Assert(inset_);
+ return inset_->cell(idx);
}
-MathArray & MathCursorPos::cell() const
+MathArray & CursorPos::cell() const
{
- lyx::Assert(par_);
- return par_->cell(idx_);
+ lyx::Assert(inset_);
+ return inset_->cell(idx_);
}
-void MathCursorPos::getPos(int & x, int & y) const
+void CursorPos::getPos(int & x, int & y) const
{
- par_->getPos(idx_, pos_, x, y);
+ inset_->getPos(idx_, pos_, x, y);
}
-void MathCursorPos::setPos(MathArray::pos_type pos)
+void CursorPos::setPos(MathArray::pos_type pos)
{
pos_ = pos;
}
-std::ostream & operator<<(std::ostream & os, MathCursorPos const & p)
+std::ostream & operator<<(std::ostream & os, CursorPos const & p)
{
- os << "(par: " << p.par_ << " idx: " << p.idx_ << " pos: " << p.pos_ << ')';
+ os << "(par: " << p.inset_ << " idx: " << p.idx_ << " pos: " << p.pos_ << ')';
return os;
}
-bool operator==(MathCursorPos const & p, MathCursorPos const & q)
+bool operator==(CursorPos const & p, CursorPos const & q)
{
- return p.par_ == q.par_ && p.idx_ == q.idx_ && p.pos_ == q.pos_;
+ return p.inset_ == q.inset_ && p.idx_ == q.idx_ && p.pos_ == q.pos_;
}
-bool operator!=(MathCursorPos const & p, MathCursorPos const & q)
+bool operator!=(CursorPos const & p, CursorPos const & q)
{
- return p.par_ != q.par_ || p.idx_ != q.idx_ || p.pos_ != q.pos_;
+ return p.inset_ != q.inset_ || p.idx_ != q.idx_ || p.pos_ != q.pos_;
}
-bool operator<(MathCursorPos const & p, MathCursorPos const & q)
+bool operator<(CursorPos const & p, CursorPos const & q)
{
- if (p.par_ != q.par_) {
+ if (p.inset_ != q.inset_) {
lyxerr << "can't compare cursor and anchor in different insets\n";
return true;
}
/// Description of a position
-class MathCursorPos {
+class CursorPos {
public:
///
- MathCursorPos();
+ CursorPos();
///
- explicit MathCursorPos(MathInset *);
+ explicit CursorPos(MathInset *);
/// returns cell corresponding to this position
MathArray & cell() const;
public:
/// pointer to an inset
- MathInset * par_;
+ MathInset * inset_;
/// cell index of a position in this inset
MathArray::idx_type idx_;
/// position in this cell
};
/// test for equality
-bool operator==(MathCursorPos const &, MathCursorPos const &);
+bool operator==(CursorPos const &, CursorPos const &);
/// test for inequality
-bool operator!=(MathCursorPos const &, MathCursorPos const &);
+bool operator!=(CursorPos const &, CursorPos const &);
/// test for order
-bool operator<(MathCursorPos const &, MathCursorPos const &);
+bool operator<(CursorPos const &, CursorPos const &);
/// output
-std::ostream & operator<<(std::ostream &, MathCursorPos const &);
+std::ostream & operator<<(std::ostream &, CursorPos const &);
#endif
{}
-MathInset * MathRootInset::clone() const
+InsetBase * MathRootInset::clone() const
{
return new MathRootInset(*this);
}
///
MathRootInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
bool idxUpDown(idx_type & idx, pos_type & pos, bool up, int targetx) const;
///
-MathInset * MathScriptInset::clone() const
+InsetBase * MathScriptInset::clone() const
{
return new MathScriptInset(*this);
}
/// create inset with single script and given nucleus
MathScriptInset(MathAtom const & at, bool up);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathSizeInset::clone() const
+InsetBase * MathSizeInset::clone() const
{
return new MathSizeInset(*this);
}
///
explicit MathSizeInset(latexkeys const * l);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
/// we write extra braces in any case...
bool extraBraces() const { return true; }
///
}
-MathInset * MathSpaceInset::clone() const
+InsetBase * MathSpaceInset::clone() const
{
return new MathSpaceInset(*this);
}
///
explicit MathSpaceInset(string const & name);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
MathSpaceInset const * asSpaceInset() const { return this; }
///
}
-MathInset * MathSplitInset::clone() const
+InsetBase * MathSplitInset::clone() const
{
return new MathSplitInset(*this);
}
///
explicit MathSplitInset(string const & name);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void write(WriteStream & os) const;
///
{}
-MathInset * MathSqrtInset::clone() const
+InsetBase * MathSqrtInset::clone() const
{
return new MathSqrtInset(*this);
}
///
MathSqrtInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void draw(PainterInfo &, int x, int y) const;
///
{}
-MathInset * MathStackrelInset::clone() const
+InsetBase * MathStackrelInset::clone() const
{
return new MathStackrelInset(*this);
}
///
MathStackrelInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathStringInset::clone() const
+InsetBase * MathStringInset::clone() const
{
return new MathStringInset(*this);
}
///
explicit MathStringInset(string const & s);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathSubstackInset::clone() const
+InsetBase * MathSubstackInset::clone() const
{
return new MathSubstackInset(*this);
}
///
MathSubstackInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
-MathInset * MathSymbolInset::clone() const
+InsetBase * MathSymbolInset::clone() const
{
return new MathSymbolInset(*this);
}
///
explicit MathSymbolInset(string const &);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathTabularInset::clone() const
+InsetBase * MathTabularInset::clone() const
{
return new MathTabularInset(*this);
}
///
MathTabularInset(string const &, char valign, string const & halign);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathTextInset::clone() const
+InsetBase * MathTextInset::clone() const
{
return new MathTextInset(*this);
}
///
MathTextInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
/// get cursor position
void getPos(idx_type idx, pos_type pos, int & x, int & y) const;
/// this stores metrics information in cache_
{}
-MathInset * MathUndersetInset::clone() const
+InsetBase * MathUndersetInset::clone() const
{
return new MathUndersetInset(*this);
}
///
MathUndersetInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathUnknownInset::clone() const
+InsetBase * MathUnknownInset::clone() const
{
return new MathUnknownInset(*this);
}
explicit MathUnknownInset(string const & name,
bool final = true, bool black = false);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi, Dimension & dim) const;
///
{}
-MathInset * MathXArrowInset::clone() const
+InsetBase * MathXArrowInset::clone() const
{
return new MathXArrowInset(*this);
}
///
explicit MathXArrowInset(string const & name);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void draw(PainterInfo & pi, int x, int y) const;
///
{}
-MathInset * MathXYArrowInset::clone() const
+InsetBase * MathXYArrowInset::clone() const
{
return new MathXYArrowInset(*this);
}
///
MathXYArrowInset();
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
void metrics(MetricsInfo & mi) const;
///
{}
-MathInset * RefInset::clone() const
+InsetBase * RefInset::clone() const
{
return new RefInset(*this);
}
///
explicit RefInset(string const & data);
///
- MathInset * clone() const;
+ InsetBase * clone() const;
///
//void write(WriteStream & os) const;
///
InsetList::iterator it = insetlist.begin();
InsetList::iterator end = insetlist.end();
for (; it != end; ++it) {
- it->inset = it->inset->clone();
+ // currently we hold Inset*, not InsetBase*
+ it->inset = static_cast<Inset*>(it->inset->clone());
// tell the new inset who is the boss now
it->inset->parOwner(this);
}
InsetList::iterator it = insetlist.begin();
InsetList::iterator end = insetlist.end();
for (; it != end; ++it) {
- it->inset = it->inset->clone();
+ it->inset = static_cast<Inset*>(it->inset->clone());
// tell the new inset who is the boss now
it->inset->parOwner(this);
}
minibuffer_inset = 0;
if (minibuffer_char == Paragraph::META_INSET) {
if (getInset(pos)) {
- minibuffer_inset = getInset(pos)->clone();
+ minibuffer_inset = static_cast<Inset *>(getInset(pos)->clone());
} else {
minibuffer_inset = 0;
minibuffer_char = ' ';
}
-vector<string> const LyXTabular::getLabelList() const
+void LyXTabular::getLabelList(std::vector<string> & list) const
{
- vector<string> label_list;
for (int i = 0; i < rows_; ++i)
- for (int j = 0; j < columns_; ++j) {
- vector<string> const l =
- getCellInset(i, j)->getLabelList();
- label_list.insert(label_list.end(),
- l.begin(), l.end());
- }
- return label_list;
+ for (int j = 0; j < columns_; ++j)
+ getCellInset(i, j)->getLabelList(list);
}
///
void validate(LaTeXFeatures &) const;
///
- std::vector<string> const getLabelList() const;
+ void getLabelList(std::vector<string> &) const;
///
/// recalculate the widths/heights only!
void reinit();
projects / lyx.git / commitdiff