2000-02-04 09:38:32 +00:00
|
|
|
// -*- C++ -*-
|
|
|
|
/* This file is part of
|
|
|
|
* ======================================================
|
|
|
|
*
|
|
|
|
* LyX, The Document Processor
|
|
|
|
*
|
|
|
|
* Copyright 1995 Matthias Ettrich
|
|
|
|
* Copyright 1995-2000 The LyX Team.
|
|
|
|
*
|
|
|
|
* ====================================================== */
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
|
|
|
#include "BufferView.h"
|
|
|
|
#include "buffer.h"
|
|
|
|
#include "lyxcursor.h"
|
|
|
|
#include "lyxtext.h"
|
|
|
|
#include "insets/inseterror.h"
|
|
|
|
#include "insets/insetinfo.h"
|
|
|
|
#include "insets/insetspecialchar.h"
|
|
|
|
#include "LyXView.h"
|
|
|
|
#include "minibuffer.h"
|
|
|
|
#include "bufferlist.h"
|
|
|
|
#include "support/FileInfo.h"
|
2000-02-17 19:59:08 +00:00
|
|
|
#include "lyxscreen.h"
|
2000-02-04 09:38:32 +00:00
|
|
|
|
|
|
|
extern BufferList bufferlist;
|
|
|
|
|
2000-02-08 15:13:01 +00:00
|
|
|
using std::ifstream;
|
|
|
|
|
2000-02-04 09:38:32 +00:00
|
|
|
// Inserts a file into current document
|
|
|
|
bool BufferView::insertLyXFile(string const & filen)
|
|
|
|
//
|
2000-03-09 03:36:48 +00:00
|
|
|
// Copyright CHT Software Service GmbH
|
2000-02-04 09:38:32 +00:00
|
|
|
// Uwe C. Schroeder
|
|
|
|
//
|
|
|
|
// Insert a Lyxformat - file into current buffer
|
|
|
|
//
|
|
|
|
// Moved from lyx_cb.C (Lgb)
|
|
|
|
{
|
|
|
|
if (filen.empty()) return false;
|
|
|
|
|
|
|
|
string fname = MakeAbsPath(filen);
|
|
|
|
|
|
|
|
// check if file exist
|
|
|
|
FileInfo fi(fname);
|
|
|
|
|
|
|
|
if (!fi.readable()) {
|
|
|
|
WriteAlert(_("Error!"),
|
|
|
|
_("Specified file is unreadable: "),
|
|
|
|
MakeDisplayPath(fname, 50));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
beforeChange();
|
|
|
|
|
|
|
|
ifstream ifs(fname.c_str());
|
|
|
|
if (!ifs) {
|
|
|
|
WriteAlert(_("Error!"),
|
|
|
|
_("Cannot open specified file: "),
|
|
|
|
MakeDisplayPath(fname, 50));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
LyXLex lex(0, 0);
|
|
|
|
lex.setStream(ifs);
|
|
|
|
char c; ifs.get(c);
|
|
|
|
ifs.putback(c);
|
|
|
|
|
|
|
|
bool res = true;
|
|
|
|
|
|
|
|
if (c == '#') {
|
|
|
|
lyxerr.debug() << "Will insert file with header" << endl;
|
|
|
|
res = buffer()->readFile(lex, text->cursor.par);
|
|
|
|
} else {
|
|
|
|
lyxerr.debug() << "Will insert file without header" << endl;
|
|
|
|
res = buffer()->readLyXformat2(lex, text->cursor.par);
|
|
|
|
}
|
|
|
|
|
|
|
|
resize();
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BufferView::removeAutoInsets()
|
|
|
|
{
|
|
|
|
LyXParagraph * par = buffer()->paragraph;
|
|
|
|
|
|
|
|
LyXCursor cursor = text->cursor;
|
|
|
|
LyXCursor tmpcursor = cursor;
|
|
|
|
cursor.par = tmpcursor.par->ParFromPos(tmpcursor.pos);
|
|
|
|
cursor.pos = tmpcursor.par->PositionInParFromPos(tmpcursor.pos);
|
|
|
|
|
|
|
|
bool a = false;
|
|
|
|
while (par) {
|
|
|
|
if (par->AutoDeleteInsets()){
|
|
|
|
a = true;
|
|
|
|
if (par->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE){
|
|
|
|
// this is possible now, since SetCursor takes
|
|
|
|
// care about footnotes
|
|
|
|
text->SetCursorIntern(par, 0);
|
|
|
|
text->RedoParagraphs(text->cursor,
|
|
|
|
text->cursor.par->Next());
|
|
|
|
text->FullRebreak();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
par = par->next;
|
|
|
|
}
|
|
|
|
// avoid forbidden cursor positions caused by error removing
|
|
|
|
if (cursor.pos > cursor.par->Last())
|
|
|
|
cursor.pos = cursor.par->Last();
|
|
|
|
text->SetCursorIntern(cursor.par, cursor.pos);
|
|
|
|
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::insertErrors(TeXErrors & terr)
|
|
|
|
{
|
|
|
|
// Save the cursor position
|
|
|
|
LyXCursor cursor = text->cursor;
|
|
|
|
|
|
|
|
// This is drastic, but it's the only fix, I could find. (Asger)
|
|
|
|
allFloats(1, 0);
|
|
|
|
allFloats(1, 1);
|
|
|
|
|
|
|
|
for (TeXErrors::Errors::const_iterator cit = terr.begin();
|
|
|
|
cit != terr.end();
|
|
|
|
++cit) {
|
|
|
|
string desctext((*cit).error_desc);
|
|
|
|
string errortext((*cit).error_text);
|
|
|
|
string msgtxt = desctext + '\n' + errortext;
|
|
|
|
int errorrow = (*cit).error_in_line;
|
|
|
|
|
|
|
|
// Insert error string for row number
|
|
|
|
int tmpid = -1;
|
|
|
|
int tmppos = -1;
|
|
|
|
|
|
|
|
buffer()->texrow.getIdFromRow(errorrow, tmpid, tmppos);
|
|
|
|
|
|
|
|
LyXParagraph * texrowpar = 0;
|
|
|
|
|
|
|
|
if (tmpid == -1) {
|
|
|
|
texrowpar = text->FirstParagraph();
|
|
|
|
tmppos = 0;
|
|
|
|
} else {
|
|
|
|
texrowpar = text->GetParFromID(tmpid);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (texrowpar == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
InsetError * new_inset = new InsetError(msgtxt);
|
|
|
|
text->SetCursorIntern(texrowpar, tmppos);
|
|
|
|
text->InsertInset(new_inset);
|
|
|
|
text->FullRebreak();
|
|
|
|
}
|
|
|
|
// Restore the cursor position
|
|
|
|
text->SetCursorIntern(cursor.par, cursor.pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::setCursorFromRow(int row)
|
|
|
|
{
|
|
|
|
int tmpid = -1;
|
|
|
|
int tmppos = -1;
|
|
|
|
|
|
|
|
buffer()->texrow.getIdFromRow(row, tmpid, tmppos);
|
|
|
|
|
|
|
|
LyXParagraph * texrowpar;
|
|
|
|
|
|
|
|
if (tmpid == -1) {
|
|
|
|
texrowpar = text->FirstParagraph();
|
|
|
|
tmppos = 0;
|
|
|
|
} else {
|
|
|
|
texrowpar = text->GetParFromID(tmpid);
|
|
|
|
}
|
|
|
|
text->SetCursor(texrowpar, tmppos);
|
|
|
|
}
|
|
|
|
|
|
|
|
void BufferView::insertInset(Inset * inset, string const & lout,
|
|
|
|
bool no_table)
|
|
|
|
{
|
|
|
|
// check for table/list in tables
|
|
|
|
if (no_table && text->cursor.par->table){
|
|
|
|
WriteAlert(_("Impossible Operation!"),
|
|
|
|
_("Cannot insert table/list in table."),
|
|
|
|
_("Sorry."));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// not quite sure if we want this...
|
|
|
|
text->SetCursorParUndo();
|
|
|
|
text->FreezeUndo();
|
|
|
|
|
|
|
|
beforeChange();
|
|
|
|
if (!lout.empty()) {
|
|
|
|
update(-2);
|
|
|
|
text->BreakParagraph();
|
|
|
|
update(-1);
|
|
|
|
|
|
|
|
if (text->cursor.par->Last()) {
|
|
|
|
text->CursorLeft();
|
|
|
|
|
|
|
|
text->BreakParagraph();
|
|
|
|
update(-1);
|
|
|
|
}
|
|
|
|
|
2000-02-29 02:19:17 +00:00
|
|
|
pair<bool, LyXTextClass::size_type> lres =
|
|
|
|
textclasslist.NumberOfLayout(buffer()->params
|
|
|
|
.textclass, lout);
|
|
|
|
LyXTextClass::size_type lay;
|
|
|
|
if (lres.first != false) {
|
|
|
|
// layout found
|
|
|
|
lay = lres.second;
|
|
|
|
} else {
|
|
|
|
// layout not fount using default "Standard" (0)
|
2000-02-04 09:38:32 +00:00
|
|
|
lay = 0;
|
2000-02-29 02:19:17 +00:00
|
|
|
}
|
|
|
|
|
2000-02-04 09:38:32 +00:00
|
|
|
text->SetLayout(lay);
|
|
|
|
|
|
|
|
text->SetParagraph(0, 0,
|
|
|
|
0, 0,
|
|
|
|
VSpace(VSpace::NONE), VSpace(VSpace::NONE),
|
|
|
|
LYX_ALIGN_LAYOUT,
|
|
|
|
string(),
|
|
|
|
0);
|
|
|
|
update(-1);
|
|
|
|
|
|
|
|
text->current_font.setLatex(LyXFont::OFF);
|
|
|
|
}
|
|
|
|
|
|
|
|
text->InsertInset(inset);
|
|
|
|
update(-1);
|
|
|
|
|
|
|
|
text->UnFreezeUndo();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Open and lock an updatable inset
|
|
|
|
void BufferView::open_new_inset(UpdatableInset * new_inset)
|
|
|
|
{
|
|
|
|
beforeChange();
|
|
|
|
text->FinishUndo();
|
|
|
|
insertInset(new_inset);
|
|
|
|
text->CursorLeft();
|
|
|
|
update(1);
|
2000-02-25 12:06:15 +00:00
|
|
|
new_inset->Edit(this, 0, 0, 0);
|
2000-02-04 09:38:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This is also a buffer property (ale) */
|
|
|
|
// Not so sure about that. a goto Label function can not be buffer local, just
|
|
|
|
// think how this will work in a multiwindo/buffer environment, all the
|
|
|
|
// cursors in all the views showing this buffer will move. (Lgb)
|
|
|
|
// OK, then no cursor action should be allowed in buffer. (ale)
|
|
|
|
bool BufferView::gotoLabel(string const & label)
|
|
|
|
|
|
|
|
{
|
|
|
|
LyXParagraph * par = buffer()->paragraph;
|
|
|
|
LyXParagraph::size_type pos;
|
|
|
|
Inset * inset;
|
|
|
|
while (par) {
|
|
|
|
pos = -1;
|
|
|
|
while ((inset = par->ReturnNextInsetPointer(pos))){
|
|
|
|
for (int i = 0; i < inset->GetNumberOfLabels(); ++i) {
|
|
|
|
if (label == inset->getLabel(i)) {
|
|
|
|
beforeChange();
|
|
|
|
text->SetCursor(par, pos);
|
|
|
|
text->sel_cursor = text->cursor;
|
|
|
|
update(0);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
++pos;
|
|
|
|
}
|
|
|
|
par = par->next;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void BufferView::allFloats(char flag, char figmar)
|
|
|
|
{
|
|
|
|
if (!available()) return;
|
|
|
|
|
|
|
|
LyXCursor cursor = text->cursor;
|
|
|
|
|
|
|
|
if (!flag && cursor.par->footnoteflag != LyXParagraph::NO_FOOTNOTE
|
|
|
|
&& ((figmar
|
|
|
|
&& cursor.par->footnotekind != LyXParagraph::FOOTNOTE
|
|
|
|
&& cursor.par->footnotekind != LyXParagraph::MARGIN)
|
|
|
|
|| (!figmar
|
|
|
|
&& cursor.par->footnotekind != LyXParagraph::FIG
|
|
|
|
&& cursor.par->footnotekind != LyXParagraph::TAB
|
|
|
|
&& cursor.par->footnotekind != LyXParagraph::WIDE_FIG
|
|
|
|
&& cursor.par->footnotekind != LyXParagraph::WIDE_TAB
|
|
|
|
&& cursor.par->footnotekind != LyXParagraph::ALGORITHM)))
|
|
|
|
toggleFloat();
|
|
|
|
else
|
|
|
|
beforeChange();
|
|
|
|
|
|
|
|
LyXCursor tmpcursor = cursor;
|
|
|
|
cursor.par = tmpcursor.par->ParFromPos(tmpcursor.pos);
|
|
|
|
cursor.pos = tmpcursor.par->PositionInParFromPos(tmpcursor.pos);
|
|
|
|
|
|
|
|
LyXParagraph *par = buffer()->paragraph;
|
|
|
|
while (par) {
|
|
|
|
if (flag) {
|
|
|
|
if (par->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE
|
|
|
|
&& ((figmar
|
|
|
|
&& par->footnotekind != LyXParagraph::FOOTNOTE
|
|
|
|
&& par->footnotekind != LyXParagraph::MARGIN)
|
|
|
|
|| (!figmar
|
|
|
|
&& par->footnotekind != LyXParagraph::FIG
|
|
|
|
&& par->footnotekind != LyXParagraph::TAB
|
|
|
|
&& par->footnotekind != LyXParagraph::WIDE_FIG
|
|
|
|
&& par->footnotekind != LyXParagraph::WIDE_TAB
|
|
|
|
&& par->footnotekind != LyXParagraph::ALGORITHM
|
|
|
|
)
|
|
|
|
)
|
|
|
|
) {
|
|
|
|
if (par->previous
|
|
|
|
&& par->previous->footnoteflag !=
|
|
|
|
LyXParagraph::CLOSED_FOOTNOTE){ /* should be */
|
|
|
|
text->SetCursorIntern(par->previous,
|
|
|
|
0);
|
|
|
|
text->OpenFootnote();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE
|
|
|
|
&& (
|
|
|
|
(figmar
|
|
|
|
&&
|
|
|
|
par->footnotekind != LyXParagraph::FOOTNOTE
|
|
|
|
&&
|
|
|
|
par->footnotekind != LyXParagraph::MARGIN
|
|
|
|
)
|
|
|
|
||
|
|
|
|
(!figmar
|
|
|
|
&&
|
|
|
|
par->footnotekind != LyXParagraph::FIG
|
|
|
|
&&
|
|
|
|
par->footnotekind != LyXParagraph::TAB
|
|
|
|
&&
|
|
|
|
par->footnotekind != LyXParagraph::WIDE_FIG
|
|
|
|
&&
|
|
|
|
par->footnotekind != LyXParagraph::WIDE_TAB
|
|
|
|
&&
|
|
|
|
par->footnotekind != LyXParagraph::ALGORITHM
|
|
|
|
)
|
|
|
|
)
|
|
|
|
) {
|
|
|
|
text->SetCursorIntern(par, 0);
|
|
|
|
text->CloseFootnote();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
par = par->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
text->SetCursorIntern(cursor.par, cursor.pos);
|
|
|
|
redraw();
|
|
|
|
fitCursor();
|
|
|
|
updateScrollbar();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::insertNote()
|
|
|
|
{
|
|
|
|
InsetInfo * new_inset = new InsetInfo();
|
|
|
|
insertInset(new_inset);
|
2000-02-25 12:06:15 +00:00
|
|
|
new_inset->Edit(this, 0, 0, 0);
|
2000-02-04 09:38:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::openStuff()
|
|
|
|
{
|
|
|
|
if (available()) {
|
|
|
|
owner()->getMiniBuffer()->Set(_("Open/Close..."));
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
beforeChange();
|
|
|
|
update(-2);
|
|
|
|
text->OpenStuff();
|
|
|
|
update(0);
|
2000-02-17 19:59:08 +00:00
|
|
|
setState();
|
2000-02-04 09:38:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::toggleFloat()
|
|
|
|
{
|
|
|
|
if (available()) {
|
|
|
|
owner()->getMiniBuffer()->Set(_("Open/Close..."));
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
beforeChange();
|
|
|
|
update(-2);
|
|
|
|
text->ToggleFootnote();
|
|
|
|
update(0);
|
2000-02-17 19:59:08 +00:00
|
|
|
setState();
|
2000-02-04 09:38:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void BufferView::menuUndo()
|
|
|
|
{
|
|
|
|
if (available()) {
|
|
|
|
owner()->getMiniBuffer()->Set(_("Undo"));
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
beforeChange();
|
|
|
|
update(-2);
|
|
|
|
if (!text->TextUndo())
|
|
|
|
owner()->getMiniBuffer()->Set(_("No further undo information"));
|
|
|
|
else
|
|
|
|
update(-1);
|
2000-02-17 19:59:08 +00:00
|
|
|
setState();
|
2000-02-04 09:38:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::menuRedo()
|
|
|
|
{
|
|
|
|
if (the_locking_inset) {
|
|
|
|
owner()->getMiniBuffer()->Set(_("Redo not yet supported in math mode"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (available()) {
|
|
|
|
owner()->getMiniBuffer()->Set(_("Redo"));
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
beforeChange();
|
|
|
|
update(-2);
|
|
|
|
if (!text->TextRedo())
|
|
|
|
owner()->getMiniBuffer()->Set(_("No further redo information"));
|
|
|
|
else
|
|
|
|
update(-1);
|
2000-02-17 19:59:08 +00:00
|
|
|
setState();
|
2000-02-04 09:38:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::hyphenationPoint()
|
|
|
|
{
|
|
|
|
if (available()) {
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
update(-2);
|
|
|
|
InsetSpecialChar * new_inset =
|
|
|
|
new InsetSpecialChar(InsetSpecialChar::HYPHENATION);
|
|
|
|
insertInset(new_inset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::ldots()
|
|
|
|
{
|
|
|
|
if (available()) {
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
update(-2);
|
|
|
|
InsetSpecialChar * new_inset =
|
|
|
|
new InsetSpecialChar(InsetSpecialChar::LDOTS);
|
|
|
|
insertInset(new_inset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::endOfSentenceDot()
|
|
|
|
{
|
|
|
|
if (available()) {
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
update(-2);
|
|
|
|
InsetSpecialChar * new_inset =
|
|
|
|
new InsetSpecialChar(InsetSpecialChar::END_OF_SENTENCE);
|
|
|
|
insertInset(new_inset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::menuSeparator()
|
|
|
|
{
|
|
|
|
if (available()) {
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
update(-2);
|
|
|
|
InsetSpecialChar * new_inset =
|
|
|
|
new InsetSpecialChar(InsetSpecialChar::MENU_SEPARATOR);
|
|
|
|
insertInset(new_inset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::newline()
|
|
|
|
{
|
|
|
|
if (available()) {
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
update(-2);
|
2000-02-29 02:19:17 +00:00
|
|
|
#if 0
|
|
|
|
InsetSpecialChar * new_inset =
|
|
|
|
new InsetSpecialChar(InsetSpecialChar::NEWLINE);
|
|
|
|
insertInset(new_inset);
|
|
|
|
#else
|
2000-02-04 09:38:32 +00:00
|
|
|
text->InsertChar(LyXParagraph::META_NEWLINE);
|
|
|
|
update(-1);
|
2000-02-29 02:19:17 +00:00
|
|
|
#endif
|
2000-02-04 09:38:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::protectedBlank()
|
|
|
|
{
|
|
|
|
if (available()) {
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
update(-2);
|
2000-02-29 02:19:17 +00:00
|
|
|
#if 1
|
|
|
|
InsetSpecialChar * new_inset =
|
|
|
|
new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR);
|
|
|
|
insertInset(new_inset);
|
|
|
|
#else
|
2000-02-04 09:38:32 +00:00
|
|
|
text->InsertChar(LyXParagraph::META_PROTECTED_SEPARATOR);
|
|
|
|
update(-1);
|
2000-02-29 02:19:17 +00:00
|
|
|
#endif
|
2000-02-04 09:38:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::hfill()
|
|
|
|
{
|
|
|
|
if (available()) {
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
update(-2);
|
|
|
|
text->InsertChar(LyXParagraph::META_HFILL);
|
|
|
|
update(-1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void BufferView::copyEnvironment()
|
|
|
|
{
|
|
|
|
if (available()) {
|
|
|
|
text->copyEnvironmentType();
|
|
|
|
// clear the selection, even if mark_set
|
2000-02-17 19:59:08 +00:00
|
|
|
toggleSelection();
|
2000-02-04 09:38:32 +00:00
|
|
|
text->ClearSelection();
|
|
|
|
update(-2);
|
|
|
|
owner()->getMiniBuffer()->Set(_("Paragraph environment type copied"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::pasteEnvironment()
|
|
|
|
{
|
|
|
|
if (available()) {
|
|
|
|
text->pasteEnvironmentType();
|
|
|
|
owner()->getMiniBuffer()->Set(_("Paragraph environment type set"));
|
|
|
|
update(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::copy()
|
|
|
|
{
|
|
|
|
if (available()) {
|
|
|
|
text->CopySelection();
|
|
|
|
// clear the selection, even if mark_set
|
2000-02-17 19:59:08 +00:00
|
|
|
toggleSelection();
|
2000-02-04 09:38:32 +00:00
|
|
|
text->ClearSelection();
|
|
|
|
update(-2);
|
|
|
|
owner()->getMiniBuffer()->Set(_("Copy"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void BufferView::cut()
|
|
|
|
{
|
|
|
|
if (available()) {
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
update(-2);
|
|
|
|
text->CutSelection();
|
|
|
|
update(1);
|
|
|
|
owner()->getMiniBuffer()->Set(_("Cut"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::paste()
|
|
|
|
{
|
|
|
|
if (!available()) return;
|
|
|
|
|
|
|
|
owner()->getMiniBuffer()->Set(_("Paste"));
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
// clear the selection
|
2000-02-17 19:59:08 +00:00
|
|
|
toggleSelection();
|
2000-02-04 09:38:32 +00:00
|
|
|
text->ClearSelection();
|
|
|
|
update(-2);
|
|
|
|
|
|
|
|
// paste
|
|
|
|
text->PasteSelection();
|
|
|
|
update(1);
|
|
|
|
|
|
|
|
// clear the selection
|
2000-02-17 19:59:08 +00:00
|
|
|
toggleSelection();
|
2000-02-04 09:38:32 +00:00
|
|
|
text->ClearSelection();
|
|
|
|
update(-2);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::gotoNote()
|
|
|
|
{
|
2000-02-17 19:59:08 +00:00
|
|
|
if (!available()) return;
|
2000-02-04 09:38:32 +00:00
|
|
|
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
beforeChange();
|
|
|
|
update(-2);
|
|
|
|
LyXCursor tmp;
|
|
|
|
|
|
|
|
if (!text->GotoNextNote()) {
|
|
|
|
if (text->cursor.pos
|
|
|
|
|| text->cursor.par != text->FirstParagraph()) {
|
|
|
|
tmp = text->cursor;
|
|
|
|
text->cursor.par = text->FirstParagraph();
|
|
|
|
text->cursor.pos = 0;
|
|
|
|
if (!text->GotoNextNote()) {
|
|
|
|
text->cursor = tmp;
|
|
|
|
owner()->getMiniBuffer()->Set(_("No more notes"));
|
|
|
|
LyXBell();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
owner()->getMiniBuffer()->Set(_("No more notes"));
|
|
|
|
LyXBell();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
update(0);
|
|
|
|
text->sel_cursor = text->cursor;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::insertCorrectQuote()
|
|
|
|
{
|
|
|
|
char c;
|
|
|
|
|
|
|
|
if (text->cursor.pos)
|
|
|
|
c = text->cursor.par->GetChar(text->cursor.pos - 1);
|
|
|
|
else
|
|
|
|
c = ' ';
|
|
|
|
|
|
|
|
insertInset(new InsetQuotes(c, buffer()->params));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* these functions are for the spellchecker */
|
|
|
|
char * BufferView::nextWord(float & value)
|
|
|
|
{
|
|
|
|
if (!available()) {
|
|
|
|
value = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
char * string = text->SelectNextWord(value);
|
|
|
|
|
|
|
|
return string;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::selectLastWord()
|
|
|
|
{
|
|
|
|
if (!available()) return;
|
|
|
|
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
beforeChange();
|
|
|
|
text->SelectSelectedWord();
|
2000-02-17 19:59:08 +00:00
|
|
|
toggleSelection(false);
|
2000-02-04 09:38:32 +00:00
|
|
|
update(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::endOfSpellCheck()
|
|
|
|
{
|
|
|
|
if (!available()) return;
|
|
|
|
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
beforeChange();
|
|
|
|
text->SelectSelectedWord();
|
|
|
|
text->ClearSelection();
|
|
|
|
update(0);
|
|
|
|
}
|
2000-02-17 19:59:08 +00:00
|
|
|
|
|
|
|
|
2000-02-04 09:38:32 +00:00
|
|
|
void BufferView::replaceWord(string const & replacestring)
|
|
|
|
{
|
2000-02-17 19:59:08 +00:00
|
|
|
if (!available()) return;
|
2000-02-04 09:38:32 +00:00
|
|
|
|
2000-02-17 19:59:08 +00:00
|
|
|
hideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
update(-2);
|
|
|
|
|
|
|
|
/* clear the selection (if there is any) */
|
2000-02-17 19:59:08 +00:00
|
|
|
toggleSelection(false);
|
2000-02-04 09:38:32 +00:00
|
|
|
update(-2);
|
|
|
|
|
|
|
|
/* clear the selection (if there is any) */
|
2000-02-17 19:59:08 +00:00
|
|
|
toggleSelection(false);
|
2000-02-04 09:38:32 +00:00
|
|
|
text->ReplaceSelectionWithString(replacestring.c_str());
|
|
|
|
|
|
|
|
text->SetSelectionOverString(replacestring.c_str());
|
|
|
|
|
|
|
|
// Go back so that replacement string is also spellchecked
|
|
|
|
for (string::size_type i = 0; i < replacestring.length() + 1; ++i) {
|
|
|
|
text->CursorLeftIntern();
|
|
|
|
}
|
|
|
|
update(1);
|
|
|
|
}
|
|
|
|
// End of spellchecker stuff
|
|
|
|
|
|
|
|
|
2000-02-25 12:06:15 +00:00
|
|
|
|
2000-02-04 09:38:32 +00:00
|
|
|
/* these functions return 1 if an error occured,
|
|
|
|
otherwise 0 */
|
|
|
|
int BufferView::lockInset(UpdatableInset * inset)
|
|
|
|
{
|
|
|
|
if (!the_locking_inset && inset){
|
|
|
|
the_locking_inset = inset;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::showLockedInsetCursor(long x, long y, int asc, int desc)
|
|
|
|
{
|
2000-02-17 19:59:08 +00:00
|
|
|
if (the_locking_inset && available()) {
|
2000-02-04 09:38:32 +00:00
|
|
|
y += text->cursor.y;
|
2000-02-17 19:59:08 +00:00
|
|
|
screen->ShowManualCursor(x, y,
|
2000-02-04 09:38:32 +00:00
|
|
|
asc, desc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-02-17 19:59:08 +00:00
|
|
|
void BufferView::hideLockedInsetCursor()
|
2000-02-04 09:38:32 +00:00
|
|
|
{
|
2000-02-17 19:59:08 +00:00
|
|
|
if (the_locking_inset && available()) {
|
2000-02-18 22:22:42 +00:00
|
|
|
screen->HideCursor();
|
2000-02-04 09:38:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::fitLockedInsetCursor(long x, long y, int asc, int desc)
|
|
|
|
{
|
2000-02-17 19:59:08 +00:00
|
|
|
if (the_locking_inset && available()){
|
2000-02-04 09:38:32 +00:00
|
|
|
y += text->cursor.y;
|
2000-02-17 19:59:08 +00:00
|
|
|
if (screen->FitManualCursor(x, y, asc, desc))
|
2000-02-04 09:38:32 +00:00
|
|
|
updateScrollbar();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int BufferView::unlockInset(UpdatableInset * inset)
|
|
|
|
{
|
|
|
|
if (inset && the_locking_inset == inset) {
|
2000-02-22 00:36:17 +00:00
|
|
|
inset->InsetUnlock(this);
|
2000-02-04 09:38:32 +00:00
|
|
|
the_locking_inset = 0;
|
|
|
|
text->FinishUndo();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return bufferlist.unlockInset(inset);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void BufferView::lockedInsetStoreUndo(Undo::undo_kind kind)
|
|
|
|
{
|
|
|
|
if (!the_locking_inset)
|
|
|
|
return; // shouldn't happen
|
|
|
|
if (kind == Undo::EDIT) // in this case insets would not be stored!
|
|
|
|
kind = Undo::FINISH;
|
|
|
|
text->SetUndo(kind,
|
|
|
|
text->cursor.par->
|
|
|
|
ParFromPos(text->cursor.pos)->previous,
|
|
|
|
text->cursor.par->
|
|
|
|
ParFromPos(text->cursor.pos)->next);
|
|
|
|
}
|
2000-02-23 16:39:03 +00:00
|
|
|
|
|
|
|
|
|
|
|
void BufferView::updateInset(Inset * inset, bool mark_dirty)
|
|
|
|
{
|
|
|
|
if (!inset)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// first check for locking insets
|
2000-02-25 12:06:15 +00:00
|
|
|
if (the_locking_inset) {
|
|
|
|
if (the_locking_inset == inset) {
|
|
|
|
if (text->UpdateInset(inset)){
|
|
|
|
update();
|
|
|
|
if (mark_dirty){
|
|
|
|
if (buffer()->isLyxClean())
|
|
|
|
owner()->getMiniBuffer()->
|
|
|
|
setTimer(4);
|
|
|
|
buffer()->markDirty();
|
|
|
|
}
|
|
|
|
updateScrollbar();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else if (the_locking_inset->UpdateInsetInInset(this,inset)) {
|
|
|
|
if (text->UpdateInset(the_locking_inset)) {
|
|
|
|
update();
|
|
|
|
if (mark_dirty){
|
|
|
|
if (buffer()->isLyxClean())
|
|
|
|
owner()->getMiniBuffer()->
|
|
|
|
setTimer(4);
|
|
|
|
buffer()->markDirty();
|
|
|
|
}
|
|
|
|
updateScrollbar();
|
|
|
|
return;
|
2000-02-23 16:39:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// then check the current buffer
|
|
|
|
if (available()) {
|
|
|
|
hideCursor();
|
|
|
|
update(-3);
|
|
|
|
if (text->UpdateInset(inset)){
|
|
|
|
if (mark_dirty)
|
|
|
|
update(1);
|
|
|
|
else
|
|
|
|
update(3);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|