* src/insets/insettoc.[Ch] (LinuxDoc, DocBook): mark the methods
as const.
+2000-02-20 Lars Gullik Bjønnes <larsbj@lyx.org>
+
+ * src/bufferlist.C: get rid of current_view from this file
+
+ * src/spellchecker.C: get rid of current_view from this file
+
+ * src/vspace.C: get rid of current_view from this file
+ (inPixels): added BufferView parameter for this func
+ (asLatexCommand): added a BufferParams for this func
+
+ * src/text.C src/text2.C: get rid of current_view from these
+ files.
+
+ * src/lyxfont.C (getFontDirection): move this function here from
+ text.C
+
+ * src/bufferparams.C (getDocumentDirection): move this function
+ here from text.C
+
+ * src/paragraph.C (getParDirection): move this function here from
+ text.C
+ (getLetterDirection): ditto
+
2000-02-18 Lars Gullik Bjønnes <larsbj@lyx.org>
* WorkArea, Painter, LyXScreen: Fixed the crash that occured on
case $gxx_version in
2.7*) CXXFLAGS="$lyx_opt";;
2.95.1) CXXFLAGS="-g $lyx_opt -fpermissive -fno-rtti";;
- 2.95.*) CXXFLAGS="-g $lyx_opt -Woverloaded-virtual -fno-rtti -fno-exceptions";;
+ 2.95.*) CXXFLAGS="-g $lyx_opt -fno-rtti -fno-exceptions";;
*2.91.*) CXXFLAGS="-g $lyx_opt -Wno-return-type -fno-exceptions -fno-rtti";;
*) CXXFLAGS="-g $lyx_opt -fno-exceptions -fno-rtti";;
esac
if (the_locking_inset) {
LyXCursor cursor = text->cursor;
the_locking_inset->
- InsetMotionNotify(x - cursor.x,
+ InsetMotionNotify(this,
+ x - cursor.x,
y - cursor.y,
state);
return;
otherwise give the event to the inset */
if (inset_hit) {
the_locking_inset->
- InsetButtonPress(xpos, ypos,
+ InsetButtonPress(this,
+ xpos, ypos,
button);
return;
} else {
selection_possible = false;
owner_->updateLayoutChoice();
owner_->getMiniBuffer()->Set(inset_hit->EditMessage());
- inset_hit->Edit(xpos, ypos);
+ inset_hit->Edit(this, xpos, ypos);
return;
}
Only a ButtonPress Event outside the inset will
force a InsetUnlock. */
the_locking_inset->
- InsetButtonRelease(x, x, button);
+ InsetButtonRelease(this, x, y, button);
return;
}
}
owner_->getMiniBuffer()->Set(inset_hit->EditMessage());
- inset_hit->Edit(x, y);
+ inset_hit->Edit(this, x, y);
return;
}
textclasslist
.TextClass(buffer_->
params.textclass).defaultfont())) {
- text->cursor.par->bibkey->Edit(0, 0);
+ text->cursor.par->bibkey->Edit(this, 0, 0);
}
return;
view->screen->CursorToggle();
} else {
view->the_locking_inset->
- ToggleInsetCursor();
+ ToggleInsetCursor(view);
}
goto set_timer_and_return;
} else {
} else {
if (!view->the_locking_inset->isCursorVisible())
view->the_locking_inset->
- ToggleInsetCursor();
+ ToggleInsetCursor(view);
}
// This is only run when work_area_focus or lyx_focus is false.
Window tmpwin;
{
if (the_locking_inset && !inset_slept) {
the_locking_inset->GetCursorPos(slx, sly);
- the_locking_inset->InsetUnlock();
+ the_locking_inset->InsetUnlock(this);
inset_slept = true;
}
}
void BufferView::insetWakeup()
{
if (the_locking_inset && inset_slept) {
- the_locking_inset->Edit(slx, sly);
+ the_locking_inset->Edit(this, slx, sly);
inset_slept = false;
}
}
void BufferView::insetUnlock()
{
if (the_locking_inset) {
- if (!inset_slept) the_locking_inset->InsetUnlock();
+ if (!inset_slept) the_locking_inset->InsetUnlock(this);
the_locking_inset = 0;
text->FinishUndo();
inset_slept = false;
insertInset(new_inset);
text->CursorLeft();
update(1);
- new_inset->Edit(0, 0);
+ new_inset->Edit(this, 0, 0);
}
/* This is also a buffer property (ale) */
{
InsetInfo * new_inset = new InsetInfo();
insertInset(new_inset);
- new_inset->Edit(0, 0);
+ new_inset->Edit(this, 0, 0);
}
int BufferView::unlockInset(UpdatableInset * inset)
{
if (inset && the_locking_inset == inset) {
- inset->InsetUnlock();
+ inset->InsetUnlock(this);
the_locking_inset = 0;
text->FinishUndo();
return 0;
///
string getText();
///
- char const * c_str();
+ char const * c_str() const;
///
Bullet & operator = (Bullet const &);
///
}
-inline char const * Bullet::c_str()
+inline char const * Bullet::c_str() const
{
return this->getText().c_str();
}
char const * spacing_string[] = {"single", "onehalf", "double", "other"};
-void Spacing::writeFile(ostream & os)
+void Spacing::writeFile(ostream & os) const
{
if (getSpace() == Spacing::Other) {
os.setf(ios::showpoint|ios::fixed);
set(sp, fval);
}
///
- void writeFile(ostream &);
+ void writeFile(ostream &) const;
///
friend bool operator!=(Spacing const & a, Spacing const & b) {
if (a.space == b.space && a.getValue() == b.getValue())
#include <cstdlib>
#include <unistd.h>
+#include <sys/types.h>
+#include <utime.h>
#ifdef __GNUG__
#pragma implementation "buffer.h"
/// Update window titles of all users
// Should work on a list
-void Buffer::updateTitles()
+void Buffer::updateTitles() const
{
if (users) users->owner()->updateWindowTitle();
}
/// Reset autosave timer of all users
// Should work on a list
-void Buffer::resetAutosaveTimers()
+void Buffer::resetAutosaveTimers() const
{
if (users) users->owner()->resetAutosaveTimer();
}
}
+
+// Should probably be moved to somewhere else: BufferView? LyXView?
+bool Buffer::save(bool makeBackup) const
+{
+ // We don't need autosaves in the immediate future. (Asger)
+ resetAutosaveTimers();
+
+ // make a backup
+ if (makeBackup) {
+ string s = fileName() + '~';
+ // Rename is the wrong way of making a backup,
+ // this is the correct way.
+ /* truss cp fil fil2:
+ lstat("LyXVC3.lyx", 0xEFFFF898) Err#2 ENOENT
+ stat("LyXVC.lyx", 0xEFFFF688) = 0
+ open("LyXVC.lyx", O_RDONLY) = 3
+ open("LyXVC3.lyx", O_WRONLY|O_CREAT|O_TRUNC, 0600) = 4
+ fstat(4, 0xEFFFF508) = 0
+ fstat(3, 0xEFFFF508) = 0
+ read(3, " # T h i s f i l e w".., 8192) = 5579
+ write(4, " # T h i s f i l e w".., 5579) = 5579
+ read(3, 0xEFFFD4A0, 8192) = 0
+ close(4) = 0
+ close(3) = 0
+ chmod("LyXVC3.lyx", 0100644) = 0
+ lseek(0, 0, SEEK_CUR) = 46440
+ _exit(0)
+ */
+
+ // Should proabaly have some more error checking here.
+ // Should be cleaned up in 0.13, at least a bit.
+ // Doing it this way, also makes the inodes stay the same.
+ // This is still not a very good solution, in particular we
+ // might loose the owner of the backup.
+ FileInfo finfo(fileName());
+ if (finfo.exist()) {
+ mode_t fmode = finfo.getMode();
+ struct utimbuf * times = new struct utimbuf;
+
+ times->actime = finfo.getAccessTime();
+ times->modtime = finfo.getModificationTime();
+ ifstream ifs(fileName().c_str());
+ ofstream ofs(s.c_str(), ios::out|ios::trunc);
+ if (ifs && ofs) {
+ ofs << ifs.rdbuf();
+ ifs.close();
+ ofs.close();
+ ::chmod(s.c_str(), fmode);
+
+ if (::utime(s.c_str(), times)) {
+ lyxerr << "utime error." << endl;
+ }
+ } else {
+ lyxerr << "LyX was not able to make "
+ "backupcopy. Beware." << endl;
+ }
+ delete times;
+ }
+ }
+
+ if (writeFile(fileName(), false)) {
+ markLyxClean();
+
+ // now delete the autosavefile
+ string a = OnlyPath(fileName());
+ a += '#';
+ a += OnlyFilename(fileName());
+ a += '#';
+ FileInfo fileinfo(a);
+ if (fileinfo.exist()) {
+ if (::remove(a.c_str()) != 0) {
+ WriteFSAlert(_("Could not delete "
+ "auto-save file!"), a);
+ }
+ }
+ } else {
+ // Saving failed, so backup is not backup
+ if (makeBackup) {
+ string s = fileName() + '~';
+ ::rename(s.c_str(), fileName().c_str());
+ }
+ return false;
+ }
+ return true;
+}
+
+
// Returns false if unsuccesful
-bool Buffer::writeFile(string const & fname, bool flag)
+bool Buffer::writeFile(string const & fname, bool flag) const
{
// if flag is false writeFile will not create any GUI
// warnings, only cerr.
{
lyxerr[Debug::LATEX] << "makeLaTeXFile..." << endl;
- // How the **** can this be needed?
- //params.textclass = current_view->buffer()->params.textclass;
-
niceFile = nice; // this will be used by Insetincludes.
tex_code_break_column = lyxrc->ascii_linelen;
}
/// Update window titles of all users
- void updateTitles();
+ void updateTitles() const;
/// Reset autosave timers for all users
- void resetAutosaveTimers();
+ void resetAutosaveTimers() const;
/** Adds the BufferView to the users list.
Later this func will insert the BufferView into a real list,
If par is given, the file is inserted. */
bool readLyXformat2(LyXLex &, LyXParagraph * par = 0);
+ /** Save file
+ Takes care of auto-save files and backup file if requested.
+ Returns true if the save is successful, false otherwise.
+ */
+ bool save(bool makeBackup) const;
+
/// Write file. Returns false if unsuccesful.
- bool writeFile(string const &, bool);
+ bool writeFile(string const &, bool) const;
///
void writeFileAscii(string const & , int);
bool isDepClean(string const & name) const;
///
- void markLyxClean() {
+ void markLyxClean() const {
if (!lyx_clean) {
lyx_clean = true;
updateTitles();
void RoffAsciiTable(ostream &, LyXParagraph * par);
/// is save needed
- bool lyx_clean;
+ mutable bool lyx_clean;
/// is autosave needed
- bool bak_clean;
+ mutable bool bak_clean;
/** do we need to run LaTeX, changed 23/03/98, Heinrich Bauer
We have to distinguish between TeX-runs executed in the original
#include <config.h>
-#include <fstream>
#include <algorithm>
-#include <sys/types.h>
-#include <utime.h>
-
#include "bufferlist.h"
#include "lyx_main.h"
#include "minibuffer.h"
#include "vc-backend.h"
#include "TextCache.h"
-extern BufferView * current_view;
extern int RunLinuxDoc(int, string const &);
-using std::ifstream;
-using std::ofstream;
-using std::ios;
using std::find;
//
}
-// Should probably be moved to somewhere else: BufferView? LyXView?
-bool BufferList::write(Buffer * buf, bool makeBackup)
-{
- if (buf->getUser())
- buf->getUser()
- ->owner()
- ->getMiniBuffer()
- ->Set(_("Saving document"),
- MakeDisplayPath(buf->fileName()), "...");
-
- // We don't need autosaves in the immediate future. (Asger)
- buf->resetAutosaveTimers();
-
- // make a backup
- if (makeBackup) {
- string s = buf->fileName() + '~';
- // Rename is the wrong way of making a backup,
- // this is the correct way.
- /* truss cp fil fil2:
- lstat("LyXVC3.lyx", 0xEFFFF898) Err#2 ENOENT
- stat("LyXVC.lyx", 0xEFFFF688) = 0
- open("LyXVC.lyx", O_RDONLY) = 3
- open("LyXVC3.lyx", O_WRONLY|O_CREAT|O_TRUNC, 0600) = 4
- fstat(4, 0xEFFFF508) = 0
- fstat(3, 0xEFFFF508) = 0
- read(3, " # T h i s f i l e w".., 8192) = 5579
- write(4, " # T h i s f i l e w".., 5579) = 5579
- read(3, 0xEFFFD4A0, 8192) = 0
- close(4) = 0
- close(3) = 0
- chmod("LyXVC3.lyx", 0100644) = 0
- lseek(0, 0, SEEK_CUR) = 46440
- _exit(0)
- */
-
- // Should proabaly have some more error checking here.
- // Should be cleaned up in 0.13, at least a bit.
- // Doing it this way, also makes the inodes stay the same.
- // This is still not a very good solution, in particular we
- // might loose the owner of the backup.
- FileInfo finfo(buf->fileName());
- if (finfo.exist()) {
- mode_t fmode = finfo.getMode();
- struct utimbuf * times = new struct utimbuf;
-
- times->actime = finfo.getAccessTime();
- times->modtime = finfo.getModificationTime();
- ifstream ifs(buf->fileName().c_str());
- ofstream ofs(s.c_str(), ios::out|ios::trunc);
- if (ifs && ofs) {
- ofs << ifs.rdbuf();
- ifs.close();
- ofs.close();
- ::chmod(s.c_str(), fmode);
-
- if (::utime(s.c_str(), times)) {
- lyxerr << "utime error." << endl;
- }
- } else {
- lyxerr << "LyX was not able to make "
- "backupcopy. Beware." << endl;
- }
- delete times;
- }
- }
-
- if (buf->writeFile(buf->fileName(), false)) {
- buf->markLyxClean();
-
- current_view->owner()->getMiniBuffer()->
- Set(_("Document saved as"),
- MakeDisplayPath(buf->fileName()));
-
- // now delete the autosavefile
- string a = OnlyPath(buf->fileName());
- a += '#';
- a += OnlyFilename(buf->fileName());
- a += '#';
- FileInfo fileinfo(a);
- if (fileinfo.exist()) {
- if (::remove(a.c_str()) != 0) {
- WriteFSAlert(_("Could not delete "
- "auto-save file!"), a);
- }
- }
- } else {
- // Saving failed, so backup is not backup
- if (makeBackup) {
- string s = buf->fileName() + '~';
- ::rename(s.c_str(), buf->fileName().c_str());
- }
- current_view->owner()->getMiniBuffer()->Set(_("Save failed!"));
- return false;
- }
-
- return true;
-}
-
-
void BufferList::closeAll()
{
state_ = BufferList::CLOSING;
MakeDisplayPath(buf->fileName(), 50),
_("Save document?"))){
case 1: // Yes
+#if 0
if (write(buf, lyxrc->make_backup)) {
lastfiles->newFile(buf->fileName());
} else {
AllowInput();
return false;
}
+#else
+ if (buf->save(lyxrc->make_backup)) {
+ lastfiles->newFile(buf->fileName());
+ } else {
+ AllowInput();
+ return false;
+ }
+#endif
break;
case 3: // Cancel
AllowInput();
bool ro = false;
switch (IsFileWriteable(s)) {
case 0:
+#if 0
current_view->owner()->getMiniBuffer()->
Set(_("File `") + MakeDisplayPath(s, 50) +
_("' is read-only."));
+#endif
ro = true;
// Fall through
case 1:
bool empty() const;
/// Saves buffer. Returns false if unsuccesful.
+#if 0
bool write(Buffer *, bool makeBackup);
+#endif
///
bool QwriteAll();
#include "debug.h"
#include "support/lyxlib.h"
#include "support/lstrings.h"
+#include "lyxrc.h"
+
+extern LyXRC * lyxrc;
BufferParams::BufferParams()
{
}
-void BufferParams::writeFile(ostream & os)
+void BufferParams::writeFile(ostream & os) const
{
// The top of the file is written by the buffer.
// Prints out the buffer info into the .lyx file given by file
// then the the preamble
if (!preamble.empty()) {
// remove '\n' from the end of preamble
- preamble = strip(preamble, '\n');
+ string tmppreamble = strip(preamble, '\n');
os << "\\begin_preamble\n"
- << preamble
+ << tmppreamble
<< "\n\\end_preamble\n";
}
}
}
}
+
+
+LyXDirection BufferParams::getDocumentDirection() const
+{
+ return (lyxrc->rtl_support && language == "hebrew")
+ ? LYX_DIR_RIGHT_TO_LEFT : LYX_DIR_LEFT_TO_RIGHT;
+}
//@}
///
- void writeFile(ostream &);
+ void writeFile(ostream &) const;
///
void useClassDefaults();
}
-void InsetFig::Edit(int, int)
+void InsetFig::Edit(BufferView * bv, int, int)
{
lyxerr.debug() << "Editing InsetFig." << endl;
Regenerate();
// We should have RO-versions of the form instead.
// The actual prevention of altering a readonly doc
// is done in CallbackFig()
- if(current_view->buffer()->isReadonly())
- WarnReadonly(current_view->buffer()->fileName());
+ if(bv->buffer()->isReadonly())
+ WarnReadonly(bv->buffer()->fileName());
if (!form) {
form = create_form_Figure();
/// what appears in the minibuffer when opening
char const * EditMessage() const { return _("Opened figure"); }
///
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
unsigned char Editable() const;
///
}
-void Inset::Edit(int, int)
+void Inset::Edit(BufferView *, int, int)
{
}
/* some stuff for inset locking */
-void UpdatableInset::InsetButtonPress(int x, int y, int button)
+void UpdatableInset::InsetButtonPress(BufferView *, int x, int y, int button)
{
lyxerr.debug() << "Inset Button Press x=" << x
<< ", y=" << y << ", button=" << button << endl;
}
-void UpdatableInset::InsetButtonRelease(int x, int y, int button)
+void UpdatableInset::InsetButtonRelease(BufferView *, int x, int y, int button)
{
lyxerr.debug() << "Inset Button Release x=" << x
<< ", y=" << y << ", button=" << button << endl;
}
-void UpdatableInset::InsetMotionNotify(int x, int y, int state)
+void UpdatableInset::InsetMotionNotify(BufferView *, int x, int y, int state)
{
lyxerr.debug() << "Inset Motion Notify x=" << x
<< ", y=" << y << ", state=" << state << endl;
}
-void UpdatableInset::InsetUnlock()
+void UpdatableInset::InsetUnlock(BufferView *)
{
lyxerr.debug() << "Inset Unlock" << endl;
}
}
-void UpdatableInset::ToggleInsetCursor()
+void UpdatableInset::ToggleInsetCursor(BufferView *)
{
}
switch (data) {
case 1: // OK, citation
{
- if(!current_view->buffer()->isReadonly()) {
- InsetCommand * inset = static_cast<InsetCommand*>(citation_form->citation_form->u_vdata);
+ InsetCitation::Holder * holder =
+ static_cast<InsetCitation::Holder*>
+ (citation_form->citation_form->u_vdata);
+ if(!holder->view->buffer()->isReadonly()) {
+
+ InsetCitation * inset = holder->inset;
inset->setContents(bibcombox->getline());
inset->setOptions(fl_get_input(citation_form->label));
fl_hide_form(citation_form->citation_form);
// shouldn't mark the buffer dirty unless something
// was actually altered
- UpdateInset(current_view, inset);
+ UpdateInset(holder->view, inset);
break;
}
// fall through to Cancel on RO-mode
break;
case 3: // OK, bibitem
{
- if(!current_view->buffer()->isReadonly()) {
- InsetCommand * inset = static_cast<InsetCommand*>(bibitem_form->bibitem_form->u_vdata);
+ InsetBibKey::Holder * holder =
+ static_cast<InsetBibKey::Holder*>
+ (bibitem_form->bibitem_form->u_vdata);
+
+ if(!holder->view->buffer()->isReadonly()) {
+ InsetBibKey * inset = holder->inset;
inset->setContents(fl_get_input(bibitem_form->key));
inset->setOptions(fl_get_input(bibitem_form->label));
fl_hide_form(bibitem_form->bibitem_form);
// Does look like a hack? It is! (but will change at 0.13)
- current_view->text->RedoParagraph();
- current_view->update(1);
+ holder->view->text->RedoParagraph();
+ holder->view->update(1);
break;
} // fall through to Cancel on RO-mode
}
{
if(citation_form && citation_form->citation_form
&& citation_form->citation_form->visible
- && citation_form->citation_form->u_vdata == this)
+ && citation_form->citation_form->u_vdata == &holder)
fl_hide_form(citation_form->citation_form);
}
-void InsetCitation::Edit(int, int)
+void InsetCitation::Edit(BufferView * bv, int, int)
{
- if(current_view->buffer()->isReadonly())
- WarnReadonly(current_view->buffer()->fileName());
+ if(bv->buffer()->isReadonly())
+ WarnReadonly(bv->buffer()->fileName());
if (!citation_form) {
citation_form = create_form_citation_form();
fl_set_form_atclose(citation_form->citation_form,
CancelCloseBoxCB, 0);
}
- citation_form->citation_form->u_vdata = this;
+
+ holder.inset = this;
+ holder.view = bv;
+
+ citation_form->citation_form->u_vdata = &holder;
BibitemUpdate(bibcombox);
if (!bibcombox->select_text(getContents().c_str()))
upwards?
(Joacim 1998-03-04)
*/
-void InsetBibKey::Edit(int, int)
+void InsetBibKey::Edit(BufferView * bv, int, int)
{
- if(current_view->buffer()->isReadonly())
- WarnReadonly(current_view->buffer()->fileName());
+ if(bv->buffer()->isReadonly())
+ WarnReadonly(bv->buffer()->fileName());
if (!bibitem_form) {
bibitem_form = create_form_bibitem_form();
fl_set_form_atclose(bibitem_form->bibitem_form,
CancelCloseBoxCB, 0);
}
- bibitem_form->bibitem_form->u_vdata = this;
+
+ holder.inset = this;
+ holder.view = bv;
+
+ bibitem_form->bibitem_form->u_vdata = &holder;
// InsetBibtex uses the same form, with different labels
fl_set_object_label(bibitem_form->key, idex(_("Key:|#K")));
fl_set_button_shortcut(bibitem_form->key, scex(_("Key:|#K")), 1);
{
// This hack is copied from InsetBibtex::Latex.
// Is it still needed? Probably yes.
- if (!owner) {
- owner = current_view->buffer();
- }
+ // Why is this needed here when it already is in Latex?
+ // Anyway we need a different way to get to the
+ // buffer the inset is in. (Lgb)
+
+ //if (!owner) {
+ // owner = current_view->buffer();
+ //}
string tmp, keys;
string bibfiles = getContents();
// BibTeX should have its own dialog. This is provisional.
-void InsetBibtex::Edit(int, int)
+void InsetBibtex::Edit(BufferView *, int, int)
{
if (!bibitem_form) {
bibitem_form = create_form_bibitem_form();
///
string getScreenLabel()const;
///
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
unsigned char Editable() const {
return 1;
}
+private:
+ ///
+ struct Holder {
+ InsetCitation * inset;
+ BufferView * view;
+ };
+
+ ///
+ Holder holder;
};
///
virtual string getScreenLabel() const;
///
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
unsigned char Editable() const {
return 1;
private:
///
int counter;
+ ///
+ struct Holder {
+ InsetBibKey * inset;
+ BufferView * view;
+ };
+
+ ///
+ Holder holder;
};
///
string getScreenLabel() const;
///
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
int Latex(ostream &, signed char) const;
///
}
-void InsetError::Edit(int, int)
+void InsetError::Edit(BufferView *, int, int)
{
static int ow = 400, oh = 240;
/// what appears in the minibuffer when opening
char const * EditMessage() const {return _("Opened error");}
///
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
unsigned char Editable() const;
///
}
-void InsetInclude::Edit(int, int)
+void InsetInclude::Edit(BufferView * bv, int, int)
{
- if(current_view->buffer()->isReadonly())
- WarnReadonly(current_view->buffer()->fileName());
+ if(bv->buffer()->isReadonly())
+ WarnReadonly(bv->buffer()->fileName());
if (!form) {
form = create_form_include();
/// This returns the list of bibkeys on the child buffer
string getKeys(char delim) const;
///
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
unsigned char Editable() const
{
}
-void InsetIndex::Edit(int, int)
+void InsetIndex::Edit(BufferView * bv, int, int)
{
- if(current_view->buffer()->isReadonly())
- WarnReadonly(current_view->buffer()->fileName());
+ if(bv->buffer()->isReadonly())
+ WarnReadonly(bv->buffer()->fileName());
if (!index_form)
index_form = create_form_index_form();
///
Inset * Clone() const { return new InsetIndex(contents);}
///
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
unsigned char Editable() const
{
/// Updates needed features for this inset.
void Validate(LaTeXFeatures & features) const;
///
- void Edit(int, int) {}
+ void Edit(BufferView *, int, int) {}
///
unsigned char Editable() const{
return 1;
}
-void InsetInfo::Edit(int, int)
+void InsetInfo::Edit(BufferView * bv, int, int)
{
static int ow = -1, oh;
- if(current_view->buffer()->isReadonly())
- WarnReadonly(current_view->buffer()->fileName());
+ if(bv->buffer()->isReadonly())
+ WarnReadonly(bv->buffer()->fileName());
if (!form) {
FL_OBJECT *obj;
/// what appears in the minibuffer when opening
char const * EditMessage() const {return _("Opened note");}
///
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
unsigned char Editable() const;
///
#include "commandtags.h"
-extern BufferView * current_view;
-
-
InsetParent::InsetParent(string const & fn, Buffer * owner)
: InsetCommand("lyxparent")
{
}
-void InsetParent::Edit(int, int)
+void InsetParent::Edit(BufferView * bv, int, int)
{
- current_view->owner()->getLyXFunc()->Dispatch(LFUN_CHILDOPEN,
- getContents().c_str());
+ bv->owner()->getLyXFunc()->Dispatch(LFUN_CHILDOPEN,
+ getContents().c_str());
}
return string(_("Parent:")) + getContents();
}
///
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
unsigned char Editable() const {
return 1;
}
-void InsetRef::Edit(int, int)
+void InsetRef::Edit(BufferView * bv, int, int)
{
- current_view->owner()->getLyXFunc()
+ bv->owner()->getLyXFunc()
->Dispatch(LFUN_REFGOTO, getContents().c_str());
}
///
Inset::Code LyxCode() const { return Inset::REF_CODE; }
///
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
unsigned char Editable() const {
return 1;
#include "lyxfunc.h"
#include "LyXView.h"
-extern BufferView * current_view;
-
-void InsetTOC::Edit(int, int)
+void InsetTOC::Edit(BufferView * bv, int, int)
{
- current_view->owner()->getLyXFunc()->Dispatch(LFUN_TOCVIEW);
+ bv->owner()->getLyXFunc()->Dispatch(LFUN_TOCVIEW);
}
int InsetTOC::Linuxdoc(string & file) const
///
string getScreenLabel() const { return _("Table of Contents"); }
/// On edit, we open the TOC pop-up
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
unsigned char Editable() const {
return 1;
#include "LaTeXFeatures.h"
#include "lyx_gui_misc.h" // CancelCloseBoxCB
-extern BufferView * current_view;
extern void UpdateInset(BufferView *, Inset * inset, bool mark_dirty = true);
+
InsetUrl::InsetUrl(string const & cmd)
: fd_form_url(0)
{
void InsetUrl::CloseUrlCB(FL_OBJECT * ob, long)
{
- InsetUrl * inset = static_cast<InsetUrl*>(ob->u_vdata);
+ Holder * holder = static_cast<Holder*>(ob->u_vdata);
+
+ InsetUrl * inset = holder->inset;
+ BufferView * bv = holder->view;
+
string url = fl_get_input(inset->fd_form_url->url_name);
string name = fl_get_input(inset->fd_form_url->name_name);
string cmdname;
else
cmdname = "url";
- Buffer * buffer = current_view->buffer();
+ Buffer * buffer = bv->buffer();
if ((url != inset->getContents() ||
name != inset->getOptions() ||
inset->flag = InsetUrl::URL;
else
inset->flag = InsetUrl::HTML_URL;
- UpdateInset(current_view, inset);
+ UpdateInset(bv, inset);
}
if (inset->fd_form_url) {
}
-void InsetUrl::Edit(int, int)
+void InsetUrl::Edit(BufferView * bv, int, int)
{
static int ow = -1, oh;
- if(current_view->buffer()->isReadonly())
- WarnReadonly(current_view->buffer()->fileName());
+ if(bv->buffer()->isReadonly())
+ WarnReadonly(bv->buffer()->fileName());
if (!fd_form_url) {
fd_form_url = create_form_form_url();
- fd_form_url->button_close->u_vdata = this;
+ holder.inset = this;
+ fd_form_url->button_close->u_vdata = &holder;
fl_set_form_atclose(fd_form_url->form_url,
CancelCloseBoxCB, 0);
}
+ holder.view = bv;
fl_set_input(fd_form_url->url_name, getContents().c_str());
fl_set_input(fd_form_url->name_name, getOptions().c_str());
switch(flag) {
///
void Validate(LaTeXFeatures &) const;
///
- void Edit(int, int);
+ void Edit(BufferView *, int, int);
///
unsigned char Editable() const {
return 1;
///
static void CloseUrlCB(FL_OBJECT *, long data);
private:
+ ///
+ struct Holder {
+ InsetUrl * inset;
+ BufferView * view;
+ };
+ ///
+ Holder holder;
+
///
Url_Flags flag;
///
class Painter;
class Buffer;
+class BufferView;
+
struct LaTeXFeatures;
/// Insets
/// what appears in the minibuffer when opening
virtual char const * EditMessage() const {return _("Opened inset");}
///
- virtual void Edit(int, int);
+ virtual void Edit(BufferView *, int, int);
///
virtual unsigned char Editable() const;
///
virtual unsigned char Editable() const;
/// may call ToggleLockedInsetCursor
- virtual void ToggleInsetCursor();
+ virtual void ToggleInsetCursor(BufferView *);
///
virtual void GetCursorPos(int &, int &) const {}
///
- virtual void InsetButtonPress(int x, int y, int button);
+ virtual void InsetButtonPress(BufferView *, int x, int y, int button);
///
- virtual void InsetButtonRelease(int x, int y, int button);
+ virtual void InsetButtonRelease(BufferView *,
+ int x, int y, int button);
///
virtual void InsetKeyPress(XKeyEvent * ev);
///
- virtual void InsetMotionNotify(int x, int y, int state);
+ virtual void InsetMotionNotify(BufferView *, int x, int y, int state);
///
- virtual void InsetUnlock();
+ virtual void InsetUnlock(BufferView *);
/// An updatable inset could handle lyx editing commands
- virtual bool LocalDispatch(int, char const *) { return false; };
+ virtual bool LocalDispatch(BufferView *, int, char const *) { return false; };
//
bool isCursorVisible() const { return cursor_visible; }
protected:
void MenuWrite(Buffer * buffer)
{
XFlush(fl_display);
- if (!bufferlist.write(buffer, lyxrc->make_backup)) {
+ if (!buffer->save(lyxrc->make_backup)) {
string fname = buffer->fileName();
string s = MakeAbsPath(fname);
if (AskQuestion(_("Save failed. Rename and try again?"),
InsetFig * new_inset = new InsetFig(100, 20, buffer);
current_view->insertInset(new_inset);
current_view->owner()->getMiniBuffer()->Set(_("Figure inserted"));
- new_inset->Edit(0, 0);
+ new_inset->Edit(current_view, 0, 0);
return;
}
Inset * new_inset = new InsetFig(100, 100, buffer);
current_view->insertInset(new_inset);
- new_inset->Edit(0, 0);
+ new_inset->Edit(current_view, 0, 0);
current_view->update(0);
current_view->owner()->getMiniBuffer()->Set(_("Figure inserted"));
current_view->text->UnFreezeUndo();
}
+LyXDirection LyXFont::getFontDirection() const
+{
+ if (lyxrc->rtl_support
+ && direction() == LyXFont::RTL_DIR
+ && latex() != LyXFont::ON)
+ return LYX_DIR_RIGHT_TO_LEFT;
+ else
+ return LYX_DIR_LEFT_TO_RIGHT;
+}
+
+
ostream & operator<<(ostream & o, LyXFont::FONT_MISC_STATE fms)
{
return o << int(fms);
owner->view()->menuUndo();
inset = static_cast<UpdatableInset*>(owner->view()->text->cursor.par->GetInset(owner->view()->text->cursor.pos));
if (inset)
- inset->Edit(slx, sly);
+ inset->Edit(owner->view(), slx, sly);
return string();
} else
if (action == LFUN_REDO) {
owner->view()->menuRedo();
inset = static_cast<UpdatableInset*>(owner->view()->text->cursor.par->GetInset(owner->view()->text->cursor.pos));
if (inset)
- inset->Edit(slx, sly);
+ inset->Edit(owner->view(),
+ slx, sly);
return string();
} else
- if (owner->view()->the_locking_inset->LocalDispatch(action, argument.c_str()))
+ if (owner->view()->the_locking_inset->LocalDispatch(owner->view(), action, argument.c_str()))
return string();
else {
setMessage(N_("Text mode"));
break;
case LFUN_MENUWRITE:
+ owner->getMiniBuffer()->Set(_("Saving document"),
+ MakeDisplayPath(owner->buffer()->fileName()),
+ "...");
MenuWrite(owner->buffer());
+ //owner->getMiniBuffer()->
+ // Set(_("Document saved as"),
+ // MakeDisplayPath(owner->buffer()->fileName()));
+ //} else {
+ //owner->getMiniBuffer()->Set(_("Save failed!"));
+ //}
break;
case LFUN_MENUWRITEAS:
case LFUN_SPELLCHECK:
if (lyxrc->isp_command != "none")
- ShowSpellChecker();
+ ShowSpellChecker(owner->view());
break; // RVDK_PATCH_5
// --- Cursor Movements -----------------------------
&& tmptext->cursor.par->GetInset(tmptext->cursor.pos)->Editable() == 2){
Inset * tmpinset = tmptext->cursor.par->GetInset(tmptext->cursor.pos);
setMessage(tmpinset->EditMessage());
- tmpinset->Edit(0, 0);
+ tmpinset->Edit(owner->view(), 0, 0);
break;
}
if (direction == LYX_DIR_LEFT_TO_RIGHT)
&& txt->cursor.par->GetInset(txt->cursor.pos)->Editable() == 2) {
Inset * tmpinset = txt->cursor.par->GetInset(txt->cursor.pos);
setMessage(tmpinset->EditMessage());
- tmpinset->Edit(tmpinset->width(owner->view()->painter(),
+ tmpinset->Edit(owner->view(),
+ tmpinset->width(owner->view()->painter(),
txt->GetFont(txt->cursor.par,
txt->cursor.pos)), 0);
break;
else
new_inset = new InsetUrl("url", "", "");
owner->view()->insertInset(new_inset);
- new_inset->Edit(0, 0);
+ new_inset->Edit(owner->view(), 0, 0);
}
break;
// Recenter screen
owner->view()->center();
-#if 0
- owner->view()->beforeChange();
- if (owner->view()->text->cursor.y >
- owner->view()->getWorkArea()->height() / 2
- ) {
- owner->view()->getScreen()->
- Draw(owner->view()->text->cursor.y -
- owner->view()->getWorkArea()->height() / 2
- );
- } else { // <=
- owner->view()->getScreen()->
- Draw(0);
- }
- owner->view()->update(0);
- owner->view()->redraw();
-#endif
}
break;
owner->view()->
open_new_inset(new InsetFormula(false));
owner->view()->
- the_locking_inset->LocalDispatch(action, argument.c_str());
+ the_locking_inset->LocalDispatch(owner->view(),
+ action,
+ argument.c_str());
}
}
break;
owner->view()->insertInset(new_inset);
} else {
owner->view()->insertInset(new_inset);
- new_inset->Edit(0, 0);
+ new_inset->Edit(owner->view(), 0, 0);
}
}
break;
owner->view()->insertInset(new_inset);
if (lsarg.empty()) {
- new_inset->Edit(0, 0);
+ new_inset->Edit(owner->view(), 0, 0);
}
}
break;
//don't edit it if the call was to INSERT_LAST
if(action != LFUN_INDEX_INSERT_LAST) {
- new_inset->Edit(0, 0);
+ new_inset->Edit(owner->view(), 0, 0);
} else {
//it looks blank on the screen unless
//we do something. put it here.
Inset * new_inset = new InsetInclude(argument,
owner->buffer());
owner->view()->insertInset(new_inset, "Standard", true);
- new_inset->Edit(0, 0);
+ new_inset->Edit(owner->view(), 0, 0);
}
break;
}
LyXLex & lex;
};
+// To avoid wrong usage:
+// pushpophelper(...); // wrong
+// pushpophelper pph(...); // right
+// we add this macro:
+#define pushpophelper(x, y, z) unnamed_pushpophelper;
+// Tip gotten from Bobby Schmidt's column in C/C++ Users Journal
#endif
LyXDirection getLetterDirection(size_type pos) const;
///
- void writeFile(ostream &, BufferParams &, char, char);
+ void writeFile(ostream &, BufferParams const &, char, char) const;
///
void validate(LaTeXFeatures &) const;
class Buffer;
class BufferParams;
-//class LyXScreen;
class Row;
class BufferView;
extern char * mathed_label;
-extern BufferView * current_view;
extern char const * latex_special_chars;
short greek_kb_flag = 0;
}
-void InsetFormula::Edit(int x, int y)
+void InsetFormula::Edit(BufferView * bv, int x, int y)
{
mathcursor = new MathedCursor(par);
- current_view->lockInset(this);
+ bv->lockInset(this);
par->Metrics();
- UpdateInset(current_view, this, false);
+ UpdateInset(bv, this, false);
x += par->xo;
y += par->yo;
mathcursor->SetPos(x, y);
}
-void InsetFormula::InsetUnlock()
+void InsetFormula::InsetUnlock(BufferView * bv)
{
if (mathcursor) {
if (mathcursor->InMacroMode()) {
mathcursor->MacroModeClose();
- UpdateLocal();
+ UpdateLocal(bv);
}
delete mathcursor;
}
mathcursor = 0;
- UpdateInset(current_view, this, false);
+ UpdateInset(bv, this, false);
}
// Now a symbol can be inserted only if the inset is locked
-void InsetFormula::InsertSymbol(char const * s)
+void InsetFormula::InsertSymbol(BufferView * bv, char const * s)
{
if (!s || !mathcursor) return;
mathcursor->Interpret(s);
- UpdateLocal();
+ UpdateLocal(bv);
}
y -= par->yo;
}
-void InsetFormula::ToggleInsetCursor()
+void InsetFormula::ToggleInsetCursor(BufferView * bv)
{
if (!mathcursor)
return;
int desc = font.maxDescent();
if (cursor_visible)
- current_view->hideLockedInsetCursor();
+ bv->hideLockedInsetCursor();
else
- current_view->showLockedInsetCursor(x, y, asc, desc);
+ bv->showLockedInsetCursor(x, y, asc, desc);
cursor_visible = !cursor_visible;
}
-void InsetFormula::ShowInsetCursor()
+void InsetFormula::ShowInsetCursor(BufferView * bv)
{
if (!cursor_visible) {
- int x, y, asc, desc;
if (mathcursor) {
+ int x, y;
mathcursor->GetPos(x, y);
// x -= par->xo;
y -= par->yo;
LyXFont font = WhichFont(LM_TC_TEXTRM, LM_ST_TEXT);
- asc = font.maxAscent();
- desc = font.maxDescent();
- current_view->fitLockedInsetCursor(x, y, asc, desc);
+ int asc = font.maxAscent();
+ int desc = font.maxDescent();
+ bv->fitLockedInsetCursor(x, y, asc, desc);
}
- ToggleInsetCursor();
+ ToggleInsetCursor(bv);
}
}
-void InsetFormula::HideInsetCursor()
+void InsetFormula::HideInsetCursor(BufferView * bv)
{
if (cursor_visible)
- ToggleInsetCursor();
+ ToggleInsetCursor(bv);
}
-void InsetFormula::ToggleInsetSelection()
+void InsetFormula::ToggleInsetSelection(BufferView * bv)
{
if (!mathcursor)
return;
// x -= par->xo;
// y -= par->yo;
- UpdateInset(current_view, this, false);
+ UpdateInset(bv, this, false);
}
}
-void InsetFormula::UpdateLocal()
+void InsetFormula::UpdateLocal(BufferView * bv)
{
par->Metrics(); // To inform lyx kernel the exact size
// (there were problems with arrays).
- UpdateInset(current_view, this);
+ UpdateInset(bv, this);
}
-void InsetFormula::InsetButtonRelease(int x, int y, int /*button*/)
+void InsetFormula::InsetButtonRelease(BufferView * bv,
+ int x, int y, int /*button*/)
{
- HideInsetCursor();
+ HideInsetCursor(bv);
x += par->xo;
y += par->yo;
mathcursor->SetPos(x, y);
- ShowInsetCursor();
+ ShowInsetCursor(bv);
if (sel_flag) {
sel_flag = false;
sel_x = sel_y = 0;
- UpdateInset(current_view, this, false);
+ UpdateInset(bv, this, false);
}
}
-void InsetFormula::InsetButtonPress(int x, int y, int /*button*/)
+void InsetFormula::InsetButtonPress(BufferView * bv,
+ int x, int y, int /*button*/)
{
sel_flag = false;
sel_x = x; sel_y = y;
if (mathcursor->Selection()) {
mathcursor->SelClear();
- UpdateInset(current_view, this, false);
+ UpdateInset(bv, this, false);
}
}
-void InsetFormula::InsetMotionNotify(int x, int y, int /*button*/)
+void InsetFormula::InsetMotionNotify(BufferView * bv,
+ int x, int y, int /*button*/)
{
if (sel_x && sel_y && abs(x-sel_x) > 4 && !sel_flag) {
sel_flag = true;
- HideInsetCursor();
+ HideInsetCursor(bv);
mathcursor->SetPos(sel_x + par->xo, sel_y + par->yo);
mathcursor->SelStart();
- ShowInsetCursor();
+ ShowInsetCursor(bv);
mathcursor->GetPos(sel_x, sel_y);
} else
if (sel_flag) {
- HideInsetCursor();
+ HideInsetCursor(bv);
x += par->xo;
y += par->yo;
mathcursor->SetPos(x, y);
- ShowInsetCursor();
+ ShowInsetCursor(bv);
mathcursor->GetPos(x, y);
if (sel_x!= x || sel_y!= y)
- UpdateInset(current_view, this, false);
+ UpdateInset(bv, this, false);
sel_x = x; sel_y = y;
}
}
}
-bool InsetFormula::LocalDispatch(int action, char const * arg)
+bool InsetFormula::LocalDispatch(BufferView * bv, int action, char const * arg)
{
// extern char *dispatch_result;
MathedTextCodes varcode = LM_TC_MIN;
bool result = true;
static MathSpaceInset * sp= 0;
- HideInsetCursor();
+ HideInsetCursor(bv);
if (mathcursor->getLastCode() == LM_TC_TEX) {
varcode = LM_TC_TEX;
break;
case LFUN_DELETE_LINE_FORWARD:
//current_view->lockedInsetStoreUndo(Undo::INSERT);
- current_view->lockedInsetStoreUndo(Undo::DELETE);
+ bv->lockedInsetStoreUndo(Undo::DELETE);
mathcursor->DelLine();
- UpdateLocal();
+ UpdateLocal(bv);
break;
case LFUN_BREAKLINE:
- current_view->lockedInsetStoreUndo(Undo::INSERT);
+ bv->lockedInsetStoreUndo(Undo::INSERT);
mathcursor->Insert(' ', LM_TC_CR);
par = mathcursor->GetPar();
- UpdateLocal();
+ UpdateLocal(bv);
break;
case LFUN_TAB:
- current_view->lockedInsetStoreUndo(Undo::INSERT);
+ bv->lockedInsetStoreUndo(Undo::INSERT);
mathcursor->Insert(0, LM_TC_TAB);
//UpdateInset(this);
break;
case LFUN_TABINSERT:
- current_view->lockedInsetStoreUndo(Undo::INSERT);
+ bv->lockedInsetStoreUndo(Undo::INSERT);
mathcursor->Insert('T', LM_TC_TAB);
- UpdateLocal();
+ UpdateLocal(bv);
break;
case LFUN_BACKSPACE:
if (!mathcursor->Left())
break;
if (!mathcursor->InMacroMode() && mathcursor->pullArg()) {
- UpdateInset(current_view, this);
+ UpdateInset(bv, this);
break;
}
case LFUN_DELETE:
//current_view->lockedInsetStoreUndo(Undo::INSERT);
- current_view->lockedInsetStoreUndo(Undo::DELETE);
+ bv->lockedInsetStoreUndo(Undo::DELETE);
mathcursor->Delete();
- UpdateInset(current_view, this);
+ UpdateInset(bv, this);
break;
// case LFUN_GETXY:
// sprintf(dispatch_buffer, "%d %d",);
case LFUN_PASTE:
if (was_macro)
mathcursor->MacroModeClose();
- current_view->lockedInsetStoreUndo(Undo::INSERT);
- mathcursor->SelPaste(); UpdateLocal(); break;
+ bv->lockedInsetStoreUndo(Undo::INSERT);
+ mathcursor->SelPaste(); UpdateLocal(bv); break;
case LFUN_CUT:
- current_view->lockedInsetStoreUndo(Undo::DELETE);
- mathcursor->SelCut(); UpdateLocal(); break;
+ bv->lockedInsetStoreUndo(Undo::DELETE);
+ mathcursor->SelCut(); UpdateLocal(bv); break;
case LFUN_COPY: mathcursor->SelCopy(); break;
case LFUN_HOMESEL:
case LFUN_ENDSEL:
{
if (!greek_kb_flag) {
greek_kb_flag = 1;
- current_view->owner()->getMiniBuffer()->Set(_("Math greek mode on"));
+ bv->owner()->getMiniBuffer()->Set(_("Math greek mode on"));
} else
greek_kb_flag = 0;
break;
{
greek_kb_flag = (greek_kb_flag) ? 0 : 2;
if (greek_kb_flag)
- current_view->owner()->getMiniBuffer()->Set(_("Math greek keyboard on"));
+ bv->owner()->getMiniBuffer()->Set(_("Math greek keyboard on"));
else
- current_view->owner()->getMiniBuffer()->Set(_("Math greek keyboard off"));
+ bv->owner()->getMiniBuffer()->Set(_("Math greek keyboard off"));
break;
}
{
// varcode = LM_TC_TEX;
mathcursor->setLastCode(LM_TC_TEX);
- current_view->owner()->getMiniBuffer()->Set(_("TeX mode"));
+ bv->owner()->getMiniBuffer()->Set(_("TeX mode"));
break;
}
case LFUN_MATH_NUMBER:
{
- current_view->lockedInsetStoreUndo(Undo::INSERT);
+ bv->lockedInsetStoreUndo(Undo::INSERT);
if (disp_flag) {
short type = par->GetType();
bool oldf = (type == LM_OT_PARN || type == LM_OT_MPARN);
if (!label.empty()) {
label.clear();
}
- current_view->owner()->getMiniBuffer()->Set(_("No number"));
+ bv->owner()->getMiniBuffer()->Set(_("No number"));
} else {
++type;
- current_view->owner()->getMiniBuffer()->Set(_("Number"));
+ bv->owner()->getMiniBuffer()->Set(_("Number"));
}
par->SetType(type);
- UpdateLocal();
+ UpdateLocal(bv);
}
break;
}
// mt->SetNumbered(!mt->IsNumbered());
mathcursor->setNumbered();
- UpdateLocal();
+ UpdateLocal(bv);
}
break;
}
case LFUN_MATH_LIMITS:
{
- current_view->lockedInsetStoreUndo(Undo::INSERT);
+ bv->lockedInsetStoreUndo(Undo::INSERT);
if (mathcursor->Limits())
- UpdateLocal();
+ UpdateLocal(bv);
}
case LFUN_MATH_SIZE:
latexkeys * l = in_word_set (arg, strlen(arg));
int sz = (l) ? l->id: -1;
mathcursor->SetSize(sz);
- UpdateLocal();
+ UpdateLocal(bv);
break;
}
case LFUN_INSERT_MATH:
{
- current_view->lockedInsetStoreUndo(Undo::INSERT);
- InsertSymbol(arg);
+ bv->lockedInsetStoreUndo(Undo::INSERT);
+ InsertSymbol(bv, arg);
break;
}
case LFUN_INSERT_MATRIX:
{
- current_view->lockedInsetStoreUndo(Undo::INSERT);
+ bv->lockedInsetStoreUndo(Undo::INSERT);
int k, m, n;
char s[80], arg2[80];
// This is just so that too long args won't ooze out of s.
if (k > 2 && int(strlen(s)) > m)
p->SetAlign(s[0], &s[1]);
mathcursor->Insert(p, LM_TC_ACTIVE_INSET);
- UpdateLocal();
+ UpdateLocal(bv);
}
break;
}
case LFUN_MATH_DELIM:
{
- current_view->lockedInsetStoreUndo(Undo::INSERT);
+ bv->lockedInsetStoreUndo(Undo::INSERT);
char lf[40], rg[40], arg2[40];
int ilf = '(', irg = '.';
latexkeys * l;
MathDelimInset * p = new MathDelimInset(ilf, irg);
mathcursor->Insert(p, LM_TC_ACTIVE_INSET);
- UpdateLocal();
+ UpdateLocal(bv);
break;
}
case LFUN_PROTECTEDSPACE:
{
- current_view->lockedInsetStoreUndo(Undo::INSERT);
+ bv->lockedInsetStoreUndo(Undo::INSERT);
sp = new MathSpaceInset(1);
mathcursor->Insert(sp);
space_on = true;
- UpdateLocal();
+ UpdateLocal(bv);
break;
}
case LFUN_INSERT_LABEL:
{
- current_view->lockedInsetStoreUndo(Undo::INSERT);
+ bv->lockedInsetStoreUndo(Undo::INSERT);
if (par->GetType() < LM_OT_PAR) break;
string lb = arg;
if (lb.empty()) {
//if (label.notEmpty()) delete label;
label = lb;
}
- UpdateLocal();
+ UpdateLocal(bv);
} else
label.clear();
break;
case LFUN_MATH_DISPLAY:
//current_view->lockedInsetStoreUndo(Undo::INSERT);
- current_view->lockedInsetStoreUndo(Undo::EDIT);
+ bv->lockedInsetStoreUndo(Undo::EDIT);
display(!disp_flag);
- UpdateLocal();
+ UpdateLocal(bv);
break;
// Invalid actions under math mode
case LFUN_MATH_MODE:
{
if (mathcursor->getLastCode()!= LM_TC_TEXTRM) {
- current_view->owner()->getMiniBuffer()->Set(_("math text mode"));
+ bv->owner()->getMiniBuffer()->Set(_("math text mode"));
varcode = LM_TC_TEXTRM;
} else {
varcode = LM_TC_VAR;
break;
}
case LFUN_UNDO:
- current_view->owner()->getMiniBuffer()->Set(_("Invalid action in math mode!"));
+ bv->owner()->getMiniBuffer()->Set(_("Invalid action in math mode!"));
break;
//------- dummy actions
case LFUN_EXEC_COMMAND:
- current_view->owner()->getMiniBuffer()->ExecCommand();
+ bv->owner()->getMiniBuffer()->ExecCommand();
break;
default:
if ((action == -1 || action == LFUN_SELFINSERT) && arg) {
unsigned char c = arg[0];
- current_view->lockedInsetStoreUndo(Undo::INSERT);
+ bv->lockedInsetStoreUndo(Undo::INSERT);
if (c == ' ' && mathcursor->getAccent() == LM_hat) {
c = '^';
if (c == '\\') {
if (was_macro)
mathcursor->MacroModeClose();
- current_view->owner()->getMiniBuffer()->Set(_("TeX mode"));
+ bv->owner()->getMiniBuffer()->Set(_("TeX mode"));
mathcursor->setLastCode(LM_TC_TEX);
}
- UpdateLocal();
+ UpdateLocal(bv);
} else {
// lyxerr << "Closed by action " << action << endl;
result = false;
if (was_macro != mathcursor->InMacroMode()
&& action >= 0
&& action != LFUN_BACKSPACE)
- UpdateLocal();
+ UpdateLocal(bv);
if (sp && !space_on) sp = 0;
if (mathcursor->Selection() || was_selection)
- ToggleInsetSelection();
+ ToggleInsetSelection(bv);
if (result)
- ShowInsetCursor();
+ ShowInsetCursor(bv);
else
- current_view->unlockInset(this);
+ bv->unlockInset(this);
return result;
}
/// what appears in the minibuffer when opening
char const * EditMessage() const {return _("Math editor mode");}
///
- void Edit(int x, int y);
+ void Edit(BufferView *, int x, int y);
///
bool display() const { return (disp_flag) ? true: false; }
///
void display(bool);
///
- void ToggleInsetCursor();
+ void ToggleInsetCursor(BufferView *);
///
- void ShowInsetCursor();
+ void ShowInsetCursor(BufferView *);
///
- void HideInsetCursor();
+ void HideInsetCursor(BufferView *);
///
void GetCursorPos(int &, int &) const;
///
- void ToggleInsetSelection();
+ void ToggleInsetSelection(BufferView * bv);
///
- void InsetButtonPress(int x, int y, int button);
+ void InsetButtonPress(BufferView *, int x, int y, int button);
///
- void InsetButtonRelease(int x, int y, int button);
+ void InsetButtonRelease(BufferView *, int x, int y, int button);
///
void InsetKeyPress(XKeyEvent * ev);
///
- void InsetMotionNotify(int x, int y, int state);
+ void InsetMotionNotify(BufferView *, int x, int y, int state);
///
- void InsetUnlock();
+ void InsetUnlock(BufferView *);
/// To allow transparent use of math editing functions
- virtual bool LocalDispatch(int, char const *);
+ virtual bool LocalDispatch(BufferView *, int, char const *);
///
- void InsertSymbol(char const *);
+ void InsertSymbol(BufferView *, char const *);
///
bool SetNumber(bool);
///
string getLabel(int) const;
protected:
- void UpdateLocal();
+ void UpdateLocal(BufferView * bv);
MathParInset * par;
- static MathedCursor* mathcursor;
+ static MathedCursor * mathcursor;
private:
bool disp_flag;
}
-void InsetFormulaMacro::Edit(int x, int y)
+void InsetFormulaMacro::Edit(BufferView * bv, int x, int y)
{
opened = true;
par = static_cast<MathParInset*>(tmacro->Clone());
- InsetFormula::Edit(x, y);
+ InsetFormula::Edit(bv, x, y);
}
-void InsetFormulaMacro::InsetUnlock()
+void InsetFormulaMacro::InsetUnlock(BufferView * bv)
{
opened = false;
LyxArrayBase * tarray = tmacro->GetData();
it.Clear();
tmacro->SetData(par->GetData());
tmacro->setEditMode(false);
- InsetFormula::InsetUnlock();
+ InsetFormula::InsetUnlock(bv);
}
-bool InsetFormulaMacro::LocalDispatch(int action, char const * arg)
+bool InsetFormulaMacro::LocalDispatch(BufferView * bv,
+ int action, char const * arg)
{
if (action == LFUN_MATH_MACROARG) {
int i = atoi(arg) - 1;
if (i >= 0 && i < tmacro->getNoArgs()) {
mathcursor->Insert(tmacro->getMacroPar(i), LM_TC_INSET);
- InsetFormula::UpdateLocal();
+ InsetFormula::UpdateLocal(bv);
}
return true;
}
tmacro->setEditMode(true);
tmacro->Metrics();
- bool result = InsetFormula::LocalDispatch(action, arg);
+ bool result = InsetFormula::LocalDispatch(bv, action, arg);
tmacro->setEditMode(false);
return result;
/// what appears in the minibuffer when opening
char const * EditMessage() const {return _("Math macro editor mode");}
///
- void Edit(int x, int y);
+ void Edit(BufferView *, int x, int y);
///
- void InsetUnlock();
+ void InsetUnlock(BufferView *);
///
- bool LocalDispatch(int, char const *);
+ bool LocalDispatch(BufferView *, int, char const *);
protected:
///
- void UpdateLocal();
+ //void UpdateLocal();
private:
///
bool opened;
current_view->beforeChange();
current_view->insertInset(new_inset);
// Update(1);//BUG
- new_inset->Edit(0, 0);
- new_inset->InsertSymbol(s);
+ new_inset->Edit(current_view, 0, 0);
+ new_inset->InsertSymbol(current_view, s);
} else
if (current_view->the_locking_inset->LyxCode() == Inset::MATH_CODE)
- static_cast<InsetFormula*>(current_view->the_locking_inset)->InsertSymbol(s);
+ static_cast<InsetFormula*>(current_view->the_locking_inset)->InsertSymbol(current_view, s);
else
lyxerr << "Math error: attempt to write on a wrong "
"class of inset." << endl;
}
-void LyXParagraph::writeFile(ostream & os, BufferParams & params,
- char footflag, char dth)
+void LyXParagraph::writeFile(ostream & os, BufferParams const & params,
+ char footflag, char dth) const
{
LyXFont font1, font2;
- Inset * inset;
int column = 0;
int h = 0;
char c = 0;
c = GetChar(i);
switch (c) {
case META_INSET:
- inset = GetInset(i);
+ {
+ Inset const * inset = GetInset(i);
if (inset)
if (inset->DirectWrite()) {
// international char, let it write
os << "\n\\end_inset \n\n";
column = 0;
}
- break;
+ }
+ break;
case META_NEWLINE:
os << "\n\\newline \n";
column = 0;
further_blank_line = true;
}
if (added_space_top.kind() != VSpace::NONE) {
- file += added_space_top.asLatexCommand();
+ file += added_space_top.asLatexCommand(current_view->buffer()->params);
further_blank_line = true;
}
}
if (added_space_bottom.kind() != VSpace::NONE) {
- file += added_space_bottom.asLatexCommand();
+ file += added_space_bottom.asLatexCommand(current_view->buffer()->params);
further_blank_line = true;
}
{
return IsWordChar(GetChar(pos)) ;
}
+
+
+LyXDirection LyXParagraph::getParDirection() const
+{
+ if (!lyxrc->rtl_support || table)
+ return LYX_DIR_LEFT_TO_RIGHT;
+
+ if (size() > 0)
+ return (getFont(0).direction() == LyXFont::RTL_DIR)
+ ? LYX_DIR_RIGHT_TO_LEFT : LYX_DIR_LEFT_TO_RIGHT;
+ else
+ return current_view->buffer()->params.getDocumentDirection();
+}
+
+
+LyXDirection
+LyXParagraph::getLetterDirection(LyXParagraph::size_type pos) const
+{
+ if (!lyxrc->rtl_support)
+ return LYX_DIR_LEFT_TO_RIGHT;
+
+ LyXDirection direction = getFont(pos).getFontDirection();
+ if (IsLineSeparator(pos) && 0 < pos && pos < Last() - 1
+ && !IsLineSeparator(pos + 1)
+ && !(table && IsNewline(pos + 1))
+ && (getFont(pos - 1).getFontDirection() != direction
+ || getFont(pos + 1).getFontDirection() != direction))
+ return getParDirection();
+ else
+ return direction;
+}
#include "debug.h"
#include "support/lstrings.h"
-extern LyXRC *lyxrc;
-extern BufferView *current_view;
+extern LyXRC * lyxrc;
// Spellchecker status
enum {
ISP_IGNORE
};
-static bool RunSpellChecker(string const &);
+static bool RunSpellChecker(BufferView * bv);
static FILE *in, *out; /* streams to communicate with ispell */
pid_t isp_pid = -1; // pid for the `ispell' process. Also used (RO) in
// Could also use a clean up. (Asger Alstrup)
static
-void create_ispell_pipe(string const & lang)
+void create_ispell_pipe(BufferParams const & params, string const & lang)
{
static char o_buf[BUFSIZ]; // jc: it could be smaller
int pipein[2], pipeout[2];
argv[argc++] = tmp;
}
if (lyxrc->isp_use_input_encoding &&
- current_view->buffer()->params.inputenc != "default") {
+ params.inputenc != "default") {
tmp = new char[3];
string("-T").copy(tmp, 2); tmp[2] = '\0';
argv[argc++] = tmp; // Input encoding
- tmp = new char[current_view->buffer()->params.inputenc.length() + 1];
- current_view->buffer()->params.inputenc.copy(tmp, current_view->buffer()->params.inputenc.length());
- tmp[current_view->buffer()->params.inputenc.length()] = '\0';
+ tmp = new char[params.inputenc.length() + 1];
+ params.inputenc.copy(tmp, params.inputenc.length());
+ tmp[params.inputenc.length()] = '\0';
argv[argc++] = tmp;
}
}
-void ShowSpellChecker()
+void ShowSpellChecker(BufferView * bv)
{
- FL_OBJECT *obj;
+ FL_OBJECT * obj;
int ret;
// Exit if we don't have a document open
- if (!current_view->available())
+ if (!bv->available())
return;
if (fd_form_spell_check == 0) {
fl_set_object_lcol(fd_form_spell_check->input, FL_BLACK);
fl_set_object_lcol(fd_form_spell_check->browser, FL_BLACK);
// activate replace only if the file is not read-only
- if (!current_view->buffer()->isReadonly()) {
+ if (!bv->buffer()->isReadonly()) {
fl_activate_object(fd_form_spell_check->replace);
fl_set_object_lcol(fd_form_spell_check->replace, FL_BLACK);
}
fl_set_object_lcol(fd_form_spell_check->options, FL_INACTIVE);
fl_set_object_lcol(fd_form_spell_check->start, FL_INACTIVE);
- ret = RunSpellChecker(current_view->buffer()->GetLanguage());
+ ret = RunSpellChecker(bv);
// deactivate insert, accept, replace, and stop
fl_deactivate_object(fd_form_spell_check->insert);
if (obj == fd_form_spell_check->done) break;
}
fl_hide_form(fd_form_spell_check->form_spell_check);
- current_view->endOfSpellCheck();
+ bv->endOfSpellCheck();
return;
}
// Perform an ispell session
static
-bool RunSpellChecker(string const & lang)
+bool RunSpellChecker(BufferView * bv)
{
- isp_result *result;
- char *word;
- int i, oldval, clickline, newvalue;
- float newval;
- FL_OBJECT *obj;
- unsigned int word_count = 0;
+ isp_result * result;
+ int i, newvalue;
+ FL_OBJECT * obj;
- string tmp = (lyxrc->isp_use_alt_lang) ? lyxrc->isp_alt_lang:lang;
+ string tmp = (lyxrc->isp_use_alt_lang) ? lyxrc->isp_alt_lang : bv->buffer()->GetLanguage();
- oldval = 0; /* used for updating slider only when needed */
- newval = 0.0;
+ int oldval = 0; /* used for updating slider only when needed */
+ float newval = 0.0;
/* create ispell process */
- create_ispell_pipe(tmp);
+ create_ispell_pipe(bv->buffer()->params, tmp);
if (isp_pid == -1) {
fl_show_message(
// Put ispell in terse mode to improve speed
ispell_terse_mode();
+ unsigned int word_count = 0;
while (true) {
- word = current_view->nextWord(newval);
+ char * word = bv->nextWord(newval);
if (word == 0) break;
++word_count;
switch (result->flag) {
case ISP_UNKNOWN:
case ISP_MISSED:
- current_view->selectLastWord();
+ {
+ bv->selectLastWord();
fl_set_object_label(fd_form_spell_check->text, word);
fl_set_input(fd_form_spell_check->input, word);
fl_clear_browser(fd_form_spell_check->browser);
fl_add_browser_line(fd_form_spell_check->browser, result->misses[i]);
}
- clickline = -1;
+ int clickline = -1;
while (true) {
obj = fl_do_forms();
if (obj == fd_form_spell_check->insert) {
if (obj == fd_form_spell_check->replace ||
obj == fd_form_spell_check->input) {
ispell_store_replacement(word, fl_get_input(fd_form_spell_check->input));
- current_view->replaceWord(fl_get_input(fd_form_spell_check->input));
+ bv->replaceWord(fl_get_input(fd_form_spell_check->input));
break;
}
if (obj == fd_form_spell_check->browser) {
if (clickline ==
fl_get_browser(fd_form_spell_check->browser)) {
ispell_store_replacement(word, fl_get_input(fd_form_spell_check->input));
- current_view->replaceWord(fl_get_input(fd_form_spell_check->input));
+ bv->replaceWord(fl_get_input(fd_form_spell_check->input));
break;
}
clickline = fl_get_browser(fd_form_spell_check->browser);
return false;
}
}
+ }
default:
delete result;
delete[] word;
}
-//void sigchldhandler(int sig)
-void sigchldhandler(pid_t pid, int *status)
+void sigchldhandler(pid_t pid, int * status)
{
- //int status ;
-
- if (isp_pid>0)
- //if (waitpid(isp_pid, &status, WNOHANG) == isp_pid) {
+ if (isp_pid > 0)
if (pid == isp_pid) {
isp_pid= -1;
fcntl(isp_fd, F_SETFL, O_NONBLOCK); /* set the file descriptor
to nonblocking so we can
continue */
}
- //sigchldchecker(sig);
sigchldchecker(pid, status);
}
/* These functions are defined in lyx_cb.C */
+class BufferView;
/** MarkLastWord should only be used immidiately after NextWord().
If you give control back to the user, you _have_ to call EndOfSpellCheck()
/** This function has to be implemented by the spell checker.
It will show the spellcheker form*/
-void ShowSpellChecker();
+void ShowSpellChecker(BufferView *);
///
void SpellCheckerOptions();
static const int LYX_PAPER_MARGIN = 20;
-extern BufferView * current_view;
extern LyXRC * lyxrc;
// ale070405
}
-LyXDirection BufferParams::getDocumentDirection() const
-{
- return (lyxrc->rtl_support && language == "hebrew")
- ? LYX_DIR_RIGHT_TO_LEFT : LYX_DIR_LEFT_TO_RIGHT;
-}
-
-LyXDirection LyXParagraph::getParDirection() const
-{
- if (!lyxrc->rtl_support || table)
- return LYX_DIR_LEFT_TO_RIGHT;
-
- if (size() > 0)
- return (getFont(0).direction() == LyXFont::RTL_DIR)
- ? LYX_DIR_RIGHT_TO_LEFT : LYX_DIR_LEFT_TO_RIGHT;
- else
- return current_view->buffer()->params.getDocumentDirection();
-}
-LyXDirection LyXFont::getFontDirection() const
-{
- if (lyxrc->rtl_support
- && direction() == LyXFont::RTL_DIR
- && latex() != LyXFont::ON)
- return LYX_DIR_RIGHT_TO_LEFT;
- else
- return LYX_DIR_LEFT_TO_RIGHT;
-}
-
-LyXDirection
-LyXParagraph::getLetterDirection(LyXParagraph::size_type pos) const
-{
- if (!lyxrc->rtl_support)
- return LYX_DIR_LEFT_TO_RIGHT;
-
- LyXDirection direction = getFont(pos).getFontDirection();
- if (IsLineSeparator(pos) && 0 < pos && pos < Last() - 1
- && !IsLineSeparator(pos + 1)
- && !(table && IsNewline(pos + 1))
- && (getFont(pos - 1).getFontDirection() != direction
- || getFont(pos + 1).getFontDirection() != direction))
- return getParDirection();
- else
- return direction;
-}
void LyXText::ComputeBidiTables(Row * row) const
x += paperwidth *
atoi(row->par->pextra_widthp.c_str()) / 100;
} else if (!row->par->pextra_width.empty()) {
- int xx = VSpace(row->par->pextra_width).inPixels();
+ int xx = VSpace(row->par->pextra_width).inPixels(owner_);
if (xx > paperwidth)
xx = paperwidth * 80 / 100;
if (layout.isParagraph()
&& firstpar->GetDepth() == 0
&& firstpar->Previous())
- maxasc += parameters->getDefSkip().inPixels();
+ maxasc += parameters->getDefSkip().inPixels(owner_);
else if (firstpar->Previous()
&& textclasslist.Style(parameters->textclass,
firstpar->Previous()->GetLayout()).isParagraph()
&& firstpar->Previous()->GetDepth() == 0)
// is it right to use defskip here too? (AS)
- maxasc += parameters->getDefSkip().inPixels();
+ maxasc += parameters->getDefSkip().inPixels(owner_);
}
/* the paper margins */
/* add the vertical spaces, that the user added */
if (firstpar->added_space_top.kind() != VSpace::NONE)
- maxasc += int(firstpar->added_space_top.inPixels());
+ maxasc += int(firstpar->added_space_top.inPixels(owner_));
/* do not forget the DTP-lines!
* there height depends on the font of the nearest character */
/* add the vertical spaces, that the user added */
if (firstpar->added_space_bottom.kind() != VSpace::NONE)
- maxdesc += int(firstpar->added_space_bottom.inPixels());
+ maxdesc += int(firstpar->added_space_bottom.inPixels(owner_));
/* do not forget the DTP-lines!
* there height depends on the font of the nearest character */
return;
}
case LyXTable::DELETE_ROW:
- if (current_view->the_locking_inset)
- current_view->unlockInset(current_view->the_locking_inset);
+ if (owner_->the_locking_inset)
+ owner_->unlockInset(owner_->the_locking_inset);
RemoveTableRow(&cursor);
RedoParagraph();
return;
LyXParagraph::size_type pos = 0;
int cell_org = actCell;
int cell = 0;
- if (current_view->the_locking_inset)
- current_view->unlockInset(current_view->the_locking_inset);
+ if (owner_->the_locking_inset)
+ owner_->unlockInset(owner_->the_locking_inset);
do {
if (!pos || (cursor.par->IsNewline(pos-1))){
if (cursor.par->table->DeleteCellIfColumnIsDeleted(cell, cell_org)){
* blank at the end of a row we have to force
* a rebreak.*/
- current_view->owner()->getMiniBuffer()
+ owner_->owner()->getMiniBuffer()
->Set(_("You cannot type two spaces this way. "
" Please read the Tutorial."));
#if 1
&& cursor.par->Previous()->footnoteflag
== LyXParagraph::OPEN_FOOTNOTE))) {
if (cursor.pos == 0 )
- current_view->owner()->getMiniBuffer()->Set(_("You cannot insert a space at the beginning of a paragraph. Please read the Tutorial."));
+ owner_->owner()->getMiniBuffer()->Set(_("You cannot insert a space at the beginning of a paragraph. Please read the Tutorial."));
else
- current_view->owner()->getMiniBuffer()->Set(_("You cannot type two spaces this way. Please read the Tutorial."));
+ owner_->owner()->getMiniBuffer()->Set(_("You cannot type two spaces this way. Please read the Tutorial."));
charInserted();
return;
}
}
/* think about user added space */
- y_top += int(row_ptr->par->added_space_top.inPixels());
+ y_top += int(row_ptr->par->added_space_top.inPixels(owner_));
/* think about the parskip */
/* some parskips VERY EASY IMPLEMENTATION */
if (layout.latextype == LATEX_PARAGRAPH
&& firstpar->GetDepth() == 0
&& firstpar->Previous())
- y_top += parameters->getDefSkip().inPixels();
+ y_top += parameters->getDefSkip().inPixels(owner_);
else if (firstpar->Previous()
&& textclasslist.Style(parameters->textclass,
firstpar->Previous()->GetLayout()).latextype == LATEX_PARAGRAPH
&& firstpar->Previous()->GetDepth() == 0)
// is it right to use defskip here, too? (AS)
- y_top += parameters->getDefSkip().inPixels();
+ y_top += parameters->getDefSkip().inPixels(owner_);
}
if (row_ptr->par->line_top) { /* draw a top line */
}
/* think about user added space */
- y_bottom -= int(firstpar->added_space_bottom.inPixels());
+ y_bottom -= int(firstpar->added_space_bottom.inPixels(owner_));
if (firstpar->line_bottom) {
/* draw a bottom line */
#define FIX_DOUBLE_SPACE 1
-extern BufferView * current_view;
-
using std::copy;
LyXText::LyXText(BufferView * bv, int pw, Buffer * p)
if (par->next
&& par->next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
OpenFootnote();
- current_view->owner()->getMiniBuffer()->Set(_("Opened float"));
+ owner_->owner()->getMiniBuffer()->Set(_("Opened float"));
} else {
- current_view->owner()->getMiniBuffer()->Set(_("Closed float"));
+ owner_->owner()->getMiniBuffer()->Set(_("Closed float"));
CloseFootnote();
}
}
void LyXText::OpenStuff()
{
if (cursor.pos == 0 && cursor.par->bibkey){
- cursor.par->bibkey->Edit(0, 0);
+ cursor.par->bibkey->Edit(owner_, 0, 0);
}
else if (cursor.pos < cursor.par->Last()
&& cursor.par->GetChar(cursor.pos) == LyXParagraph::META_INSET
&& cursor.par->GetInset(cursor.pos)->Editable()) {
- current_view->owner()->getMiniBuffer()
+ owner_->owner()->getMiniBuffer()
->Set(cursor.par->GetInset(cursor.pos)->EditMessage());
if (cursor.par->GetInset(cursor.pos)->Editable() != 2)
SetCursorParUndo();
- cursor.par->GetInset(cursor.pos)->Edit(0, 0);
+ cursor.par->GetInset(cursor.pos)->Edit(owner_, 0, 0);
} else {
ToggleFootnote();
}
if (!par->next ||
par->next->footnoteflag != LyXParagraph::OPEN_FOOTNOTE) {
- current_view->owner()->getMiniBuffer()
+ owner_->owner()->getMiniBuffer()
->Set(_("Nothing to do"));
return;
}
// If the mask is completely neutral, tell user
if (font == LyXFont(LyXFont::ALL_IGNORE)) {
// Could only happen with user style
- current_view->owner()->getMiniBuffer()
+ owner_->owner()->getMiniBuffer()
->Set(_("No font change defined. Use Character under"
" the Layout menu to define font change."));
return;
current_font = cursor.par->GetFontSettings(cursor.pos);
real_current_font = GetFont(cursor.par, cursor.pos);
if (pos == 0 && par->size() == 0
- && current_view->buffer()->params.getDocumentDirection() == LYX_DIR_RIGHT_TO_LEFT) {
+ && owner_->buffer()->params.getDocumentDirection() == LYX_DIR_RIGHT_TO_LEFT) {
current_font.setDirection(LyXFont::RTL_DIR);
real_current_font.setDirection(LyXFont::RTL_DIR);
}
#include "support/lstrings.h"
extern LyXRC * lyxrc;
-extern BufferView * current_view;
/* length units
*/
}
-string VSpace::asLatexCommand() const
+string VSpace::asLatexCommand(BufferParams const & params) const
{
switch (kin) {
case NONE: return string();
case DEFSKIP:
- return current_view->buffer()->params.getDefSkip().asLatexCommand();
+ return params.getDefSkip().asLatexCommand(params);
case SMALLSKIP: return kp ? "\\vspace*{\\smallskipamount}"
: "\\smallskip{}";
case MEDSKIP: return kp ? "\\vspace*{\\medskipamount}"
}
-int VSpace::inPixels() const
+int VSpace::inPixels(BufferView * bv) const
{
// Height of a normal line in pixels (zoom factor considered)
- int height = current_view->text->DefaultHeight(); // [pixels]
+ int height = bv->text->DefaultHeight(); // [pixels]
// Zoom factor specified by user in percent
float const zoom = lyxrc->zoom / 100.0; // [percent]
case NONE: return 0;
case DEFSKIP:
- return current_view->buffer()->params.getDefSkip().inPixels();
+ return bv->buffer()->params.getDefSkip().inPixels(bv);
// This is how the skips are normally defined by
// LateX. But there should be some way to change
*
* LyX, The Document Processor
*
- * Copyright (C) 1995 1996 Matthias Ettrich
- * and the LyX Team.
+ * Copyright 1995 Matthias Ettrich
+ * Copyright 1995-2000 The LyX Team.
*
* ====================================================== */
#include "LString.h"
+class BufferParams;
+class BufferView;
+
/// LyXLength Class
class LyXLength {
public:
///
string asLyXCommand() const; // how it goes into the LyX file
///
- string asLatexCommand() const;
+ string asLatexCommand(BufferParams const & params) const;
///
- int inPixels() const;
+ int inPixels(BufferView * bv) const;
private:
///
vspace_kind kin;
projects / features.git / commitdiff