1999-09-27 18:44:28 +00:00
|
|
|
/* This file is part of
|
1999-11-15 12:01:38 +00:00
|
|
|
* ======================================================
|
1999-10-02 16:21:10 +00:00
|
|
|
*
|
|
|
|
* LyX, The Document Processor
|
|
|
|
*
|
|
|
|
* Copyright 1995 Matthias Ettrich,
|
2000-02-04 09:38:32 +00:00
|
|
|
* Copyright 1995-2000 The LyX Team.
|
1999-10-02 16:21:10 +00:00
|
|
|
*
|
1999-11-15 12:01:38 +00:00
|
|
|
* ====================================================== */
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
2000-01-06 11:35:29 +00:00
|
|
|
#include <fstream>
|
2000-03-20 18:55:57 +00:00
|
|
|
#include <algorithm>
|
2000-04-08 17:02:02 +00:00
|
|
|
#include <iostream>
|
2000-03-16 04:29:22 +00:00
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
#include FORMS_H_LOCATION
|
|
|
|
#include "lyx.h"
|
2000-04-12 14:20:08 +00:00
|
|
|
#include "lyx_main.h"
|
1999-09-27 18:44:28 +00:00
|
|
|
#include "lyx_cb.h"
|
|
|
|
#include "insets/insetlabel.h"
|
|
|
|
#include "insets/figinset.h"
|
|
|
|
#include "lyxfunc.h"
|
|
|
|
#include "minibuffer.h"
|
|
|
|
#include "combox.h"
|
|
|
|
#include "bufferlist.h"
|
|
|
|
#include "filedlg.h"
|
|
|
|
#include "lyx_gui_misc.h"
|
2000-02-04 09:38:32 +00:00
|
|
|
#include "LyXView.h"
|
1999-09-27 18:44:28 +00:00
|
|
|
#include "lastfiles.h"
|
2000-04-12 14:20:08 +00:00
|
|
|
#include "bufferview_funcs.h"
|
1999-10-02 16:21:10 +00:00
|
|
|
#include "support/FileInfo.h"
|
|
|
|
#include "support/syscall.h"
|
2000-04-12 14:20:08 +00:00
|
|
|
#include "support/filetools.h"
|
|
|
|
#include "support/path.h"
|
1999-09-27 18:44:28 +00:00
|
|
|
#include "lyxrc.h"
|
|
|
|
#include "lyxtext.h"
|
|
|
|
|
2000-03-28 02:18:55 +00:00
|
|
|
using std::ifstream;
|
|
|
|
using std::copy;
|
|
|
|
using std::back_inserter;
|
|
|
|
using std::endl;
|
|
|
|
using std::cout;
|
|
|
|
using std::ios;
|
|
|
|
using std::istream_iterator;
|
2000-04-04 00:19:15 +00:00
|
|
|
using std::pair;
|
2000-05-19 16:46:01 +00:00
|
|
|
using std::vector;
|
|
|
|
using std::sort;
|
2000-05-20 21:37:05 +00:00
|
|
|
using std::equal;
|
2000-03-28 02:18:55 +00:00
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
extern BufferList bufferlist;
|
|
|
|
extern void show_symbols_form();
|
1999-11-26 06:57:35 +00:00
|
|
|
extern FD_form_figure * fd_form_figure;
|
|
|
|
|
|
|
|
extern BufferView * current_view; // called too many times in this file...
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
extern void DeleteSimpleCutBuffer(); /* for the cleanup when exiting */
|
|
|
|
|
1999-12-15 17:42:22 +00:00
|
|
|
extern void MenuSendto();
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
// this should be static, but I need it in buffer.C
|
|
|
|
bool quitting; // flag, that we are quitting the program
|
|
|
|
extern bool finished; // all cleanup done just let it run through now.
|
|
|
|
|
|
|
|
char ascii_type; /* for selection notify callbacks */
|
|
|
|
|
|
|
|
bool scrolling = false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
This is the inset locking stuff needed for mathed --------------------
|
|
|
|
|
|
|
|
an inset can simple call LockInset in it's edit call and *ONLY* in it's
|
|
|
|
edit call.
|
|
|
|
Inset::Edit() can only be called by the main lyx module.
|
|
|
|
|
|
|
|
Then the inset may modify the menu's and/or iconbars.
|
|
|
|
|
|
|
|
Unlocking is either done by LyX or the inset itself with a UnlockInset-call
|
|
|
|
|
|
|
|
During the lock, all button and keyboard events will be modified
|
|
|
|
and send to the inset through the following inset-features. Note that
|
|
|
|
Inset::InsetUnlock will be called from inside UnlockInset. It is meant
|
|
|
|
to contain the code for restoring the menus and things like this.
|
|
|
|
|
|
|
|
|
|
|
|
virtual void InsetButtonPress(int x, int y, int button);
|
|
|
|
virtual void InsetButtonRelease(int x, int y, int button);
|
|
|
|
virtual void InsetKeyPress(XKeyEvent *ev);
|
|
|
|
virtual void InsetMotionNotify(int x, int y, int state);
|
|
|
|
virtual void InsetUnlock();
|
|
|
|
|
|
|
|
If a inset wishes any redraw and/or update it just has to call
|
|
|
|
UpdateInset(this).
|
|
|
|
It's is completly irrelevant, where the inset is. UpdateInset will
|
|
|
|
find it in any paragraph in any buffer.
|
|
|
|
Of course the_locking_inset and the insets in the current paragraph/buffer
|
|
|
|
are checked first, so no performance problem should occur.
|
|
|
|
|
|
|
|
Hope that's ok for the beginning, Alejandro,
|
|
|
|
sorry that I needed so much time,
|
|
|
|
|
|
|
|
Matthias
|
|
|
|
*/
|
|
|
|
|
2000-02-23 16:39:03 +00:00
|
|
|
//void UpdateInset(BufferView * bv, Inset * inset, bool mark_dirty = true);
|
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
/* these functions return 1 if an error occured,
|
|
|
|
otherwise 0 */
|
|
|
|
// Now they work only for updatable insets. [Alejandro 080596]
|
2000-01-08 21:02:58 +00:00
|
|
|
//int LockInset(UpdatableInset * inset);
|
2000-09-29 18:44:07 +00:00
|
|
|
void ToggleLockedInsetCursor(int x, int y, int asc, int desc);
|
2000-01-08 21:02:58 +00:00
|
|
|
//void FitLockedInsetCursor(long x, long y, int asc, int desc);
|
|
|
|
//int UnlockInset(UpdatableInset * inset);
|
|
|
|
//void LockedInsetStoreUndo(Undo::undo_kind kind);
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
/* this is for asyncron updating. UpdateInsetUpdateList will be called
|
|
|
|
automatically from LyX. Just insert the Inset into the Updatelist */
|
2000-02-23 16:39:03 +00:00
|
|
|
//void UpdateInsetUpdateList();
|
|
|
|
//void PutInsetIntoInsetUpdateList(Inset * inset);
|
1999-09-27 18:44:28 +00:00
|
|
|
|
2000-02-23 16:39:03 +00:00
|
|
|
//InsetUpdateStruct * InsetUpdateList = 0;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
-----------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2000-10-10 11:50:43 +00:00
|
|
|
void ShowMessage(Buffer const * buf,
|
2000-03-28 02:18:55 +00:00
|
|
|
string const & msg1,
|
2000-08-30 04:38:32 +00:00
|
|
|
string const & msg2,
|
|
|
|
string const & msg3, int delay)
|
2000-03-20 16:37:50 +00:00
|
|
|
{
|
2000-10-23 12:16:05 +00:00
|
|
|
if (lyxrc.use_gui)
|
2000-03-28 02:18:55 +00:00
|
|
|
buf->getUser()->owner()->getMiniBuffer()->Set(msg1, msg2,
|
|
|
|
msg3, delay);
|
2000-10-23 12:16:05 +00:00
|
|
|
else
|
|
|
|
lyxerr << msg1 << msg2 << msg3 << endl;
|
2000-03-20 16:37:50 +00:00
|
|
|
}
|
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
//
|
|
|
|
// Menu callbacks
|
|
|
|
//
|
|
|
|
|
|
|
|
//
|
|
|
|
// File menu
|
|
|
|
//
|
|
|
|
|
|
|
|
// should be moved to lyxfunc.C
|
2000-11-14 02:01:57 +00:00
|
|
|
bool MenuWrite(BufferView * bv, Buffer * buffer)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2000-10-11 21:06:43 +00:00
|
|
|
XFlush(fl_get_display());
|
2000-03-20 14:49:54 +00:00
|
|
|
if (!buffer->save()) {
|
2000-11-14 02:01:57 +00:00
|
|
|
string const fname = buffer->fileName();
|
|
|
|
string const s = MakeAbsPath(fname);
|
1999-09-27 18:44:28 +00:00
|
|
|
if (AskQuestion(_("Save failed. Rename and try again?"),
|
1999-12-16 06:43:25 +00:00
|
|
|
MakeDisplayPath(s, 50),
|
|
|
|
_("(If not, document is not saved.)"))) {
|
2000-11-14 02:01:57 +00:00
|
|
|
return MenuWriteAs(bv, buffer);
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
2000-08-08 15:36:25 +00:00
|
|
|
return false;
|
1999-09-27 18:44:28 +00:00
|
|
|
} else {
|
2000-01-07 03:42:16 +00:00
|
|
|
lastfiles->newFile(buffer->fileName());
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
2000-08-08 15:36:25 +00:00
|
|
|
return true;
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// should be moved to BufferView.C
|
2000-01-07 03:42:16 +00:00
|
|
|
// Half of this func should be in LyXView, the rest in BufferView.
|
2000-11-14 02:01:57 +00:00
|
|
|
bool MenuWriteAs(BufferView * bv, Buffer * buffer)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2000-01-07 03:42:16 +00:00
|
|
|
// Why do we require BufferView::text to be able to write a
|
|
|
|
// document? I see no point in that. (Lgb)
|
|
|
|
//if (!bv->text) return;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
1999-12-10 00:07:59 +00:00
|
|
|
string fname = buffer->fileName();
|
1999-10-02 16:21:10 +00:00
|
|
|
string oldname = fname;
|
1999-09-27 18:44:28 +00:00
|
|
|
LyXFileDlg fileDlg;
|
|
|
|
|
2000-11-14 02:01:57 +00:00
|
|
|
ProhibitInput(bv);
|
2000-03-12 10:35:05 +00:00
|
|
|
fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
|
|
|
|
fileDlg.SetButton(1, _("Templates"), lyxrc.template_path);
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
if (!IsLyXFilename(fname))
|
|
|
|
fname += ".lyx";
|
|
|
|
|
2000-11-10 17:29:47 +00:00
|
|
|
fname = fileDlg.Select(_("Enter Filename to Save Document as"),
|
|
|
|
OnlyPath(fname),
|
|
|
|
"*.lyx",
|
|
|
|
OnlyFilename(fname));
|
|
|
|
|
2000-11-14 02:01:57 +00:00
|
|
|
AllowInput(bv);
|
1999-09-27 18:44:28 +00:00
|
|
|
|
2000-11-10 17:29:47 +00:00
|
|
|
if (fname.empty())
|
2000-07-26 13:43:16 +00:00
|
|
|
return false;
|
2000-11-10 17:29:47 +00:00
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
// Make sure the absolute filename ends with appropriate suffix
|
1999-11-15 12:01:38 +00:00
|
|
|
string s = MakeAbsPath(fname);
|
1999-09-27 18:44:28 +00:00
|
|
|
if (!IsLyXFilename(s))
|
|
|
|
s += ".lyx";
|
|
|
|
|
|
|
|
// Same name as we have already?
|
2000-11-10 17:29:47 +00:00
|
|
|
if (!buffer->isUnnamed() && s == oldname) {
|
1999-09-27 18:44:28 +00:00
|
|
|
if (!AskQuestion(_("Same name as document already has:"),
|
1999-11-15 12:01:38 +00:00
|
|
|
MakeDisplayPath(s, 50),
|
1999-09-27 18:44:28 +00:00
|
|
|
_("Save anyway?")))
|
2000-07-26 13:43:16 +00:00
|
|
|
return false;
|
1999-09-27 18:44:28 +00:00
|
|
|
// Falls through to name change and save
|
|
|
|
}
|
|
|
|
// No, but do we have another file with this name open?
|
2000-11-10 17:29:47 +00:00
|
|
|
else if (!buffer->isUnnamed() && bufferlist.exists(s)) {
|
1999-09-27 18:44:28 +00:00
|
|
|
if (AskQuestion(_("Another document with same name open!"),
|
1999-11-15 12:01:38 +00:00
|
|
|
MakeDisplayPath(s, 50),
|
1999-09-27 18:44:28 +00:00
|
|
|
_("Replace with current document?")))
|
|
|
|
{
|
|
|
|
bufferlist.close(bufferlist.getBuffer(s));
|
|
|
|
|
|
|
|
// Ok, change the name of the buffer, but don't save!
|
2000-10-12 00:11:06 +00:00
|
|
|
buffer->setFileName(s);
|
1999-09-27 18:44:28 +00:00
|
|
|
buffer->markDirty();
|
|
|
|
|
2000-03-20 16:37:50 +00:00
|
|
|
ShowMessage(buffer, _("Document renamed to '"),
|
|
|
|
MakeDisplayPath(s), _("', but not saved..."));
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
2000-07-26 13:43:16 +00:00
|
|
|
return false;
|
1999-09-27 18:44:28 +00:00
|
|
|
} // Check whether the file exists
|
|
|
|
else {
|
2000-11-14 02:01:57 +00:00
|
|
|
FileInfo const myfile(s);
|
1999-09-27 18:44:28 +00:00
|
|
|
if (myfile.isOK() && !AskQuestion(_("Document already exists:"),
|
1999-11-15 12:01:38 +00:00
|
|
|
MakeDisplayPath(s, 50),
|
1999-09-27 18:44:28 +00:00
|
|
|
_("Replace file?")))
|
2000-07-26 13:43:16 +00:00
|
|
|
return false;
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Ok, change the name of the buffer
|
2000-10-12 00:11:06 +00:00
|
|
|
buffer->setFileName(s);
|
1999-09-27 18:44:28 +00:00
|
|
|
buffer->markDirty();
|
2000-08-08 15:36:25 +00:00
|
|
|
bool unnamed = buffer->isUnnamed();
|
2000-07-26 13:43:16 +00:00
|
|
|
buffer->setUnnamed(false);
|
1999-09-27 18:44:28 +00:00
|
|
|
// And save
|
|
|
|
// Small bug: If the save fails, we have irreversible changed the name
|
|
|
|
// of the document.
|
2000-08-08 15:36:25 +00:00
|
|
|
// Hope this is fixed this way! (Jug)
|
2000-11-14 02:01:57 +00:00
|
|
|
if (!MenuWrite(bv, buffer)) {
|
2000-10-12 00:11:06 +00:00
|
|
|
buffer->setFileName(oldname);
|
2000-08-08 15:36:25 +00:00
|
|
|
buffer->setUnnamed(unnamed);
|
|
|
|
ShowMessage(buffer, _("Document could not be saved!"),
|
|
|
|
_("Holding the old name."), MakeDisplayPath(oldname));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// now remove the oldname autosave file if existant!
|
|
|
|
removeAutosaveFile(oldname);
|
2000-07-26 13:43:16 +00:00
|
|
|
return true;
|
2000-08-08 15:36:25 +00:00
|
|
|
}
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
|
1999-11-26 06:57:35 +00:00
|
|
|
int MenuRunChktex(Buffer * buffer)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (buffer->isSGML()) {
|
|
|
|
WriteAlert(_("Chktex does not work with SGML derived documents."));
|
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
ret = buffer->runChktex();
|
|
|
|
|
|
|
|
if (ret >= 0) {
|
1999-10-02 16:21:10 +00:00
|
|
|
string s;
|
|
|
|
string t;
|
1999-09-27 18:44:28 +00:00
|
|
|
if (ret == 0) {
|
|
|
|
s = _("No warnings found.");
|
|
|
|
} else if (ret == 1) {
|
|
|
|
s = _("One warning found.");
|
|
|
|
t = _("Use 'Edit->Go to Error' to find it.");
|
|
|
|
} else {
|
1999-10-19 16:48:35 +00:00
|
|
|
s += tostr(ret);
|
1999-09-27 18:44:28 +00:00
|
|
|
s += _(" warnings found.");
|
|
|
|
t = _("Use 'Edit->Go to Error' to find them.");
|
|
|
|
}
|
|
|
|
WriteAlert(_("Chktex run successfully"), s, t);
|
|
|
|
} else {
|
1999-11-15 12:01:38 +00:00
|
|
|
WriteAlert(_("Error!"), _("It seems chktex does not work."));
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2000-11-14 02:01:57 +00:00
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
void QuitLyX()
|
|
|
|
{
|
1999-10-07 18:44:17 +00:00
|
|
|
lyxerr.debug() << "Running QuitLyX." << endl;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
2001-02-01 17:37:09 +00:00
|
|
|
if (lyxrc.use_gui) {
|
|
|
|
if (!bufferlist.QwriteAll())
|
|
|
|
return;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
2001-02-01 17:37:09 +00:00
|
|
|
lastfiles->writeFile(lyxrc.lastfiles);
|
|
|
|
}
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
// Set a flag that we do quitting from the program,
|
|
|
|
// so no refreshes are necessary.
|
|
|
|
quitting = true;
|
|
|
|
|
|
|
|
// close buffers first
|
|
|
|
bufferlist.closeAll();
|
|
|
|
|
|
|
|
// do any other cleanup procedures now
|
1999-10-07 18:44:17 +00:00
|
|
|
lyxerr.debug() << "Deleting tmp dir " << system_tempdir << endl;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
DestroyLyXTmpDir(system_tempdir);
|
|
|
|
|
|
|
|
finished = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2000-04-11 22:55:29 +00:00
|
|
|
void AutoSave(BufferView * bv)
|
1999-09-27 18:44:28 +00:00
|
|
|
// should probably be moved into BufferList (Lgb)
|
|
|
|
// Perfect target for a thread...
|
|
|
|
{
|
2000-04-11 22:55:29 +00:00
|
|
|
if (!bv->available())
|
1999-09-27 18:44:28 +00:00
|
|
|
return;
|
|
|
|
|
2000-08-08 15:36:25 +00:00
|
|
|
if (bv->buffer()->isBakClean() || bv->buffer()->isReadonly()) {
|
1999-09-27 18:44:28 +00:00
|
|
|
// We don't save now, but we'll try again later
|
2000-04-11 22:55:29 +00:00
|
|
|
bv->owner()->resetAutosaveTimer();
|
1999-09-27 18:44:28 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2000-04-11 22:55:29 +00:00
|
|
|
bv->owner()->getMiniBuffer()->Set(_("Autosaving current document..."));
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
// create autosave filename
|
2000-04-11 22:55:29 +00:00
|
|
|
string fname = OnlyPath(bv->buffer()->fileName());
|
1999-09-27 18:44:28 +00:00
|
|
|
fname += "#";
|
2000-04-11 22:55:29 +00:00
|
|
|
fname += OnlyFilename(bv->buffer()->fileName());
|
1999-09-27 18:44:28 +00:00
|
|
|
fname += "#";
|
|
|
|
|
|
|
|
// tmp_ret will be located (usually) in /tmp
|
|
|
|
// will that be a problem?
|
2000-11-14 02:01:57 +00:00
|
|
|
pid_t const pid = fork(); // If you want to debug the autosave
|
1999-09-27 18:44:28 +00:00
|
|
|
// you should set pid to -1, and comment out the
|
|
|
|
// fork.
|
|
|
|
if (pid == 0 || pid == -1) {
|
|
|
|
// pid = -1 signifies that lyx was unable
|
|
|
|
// to fork. But we will do the save
|
|
|
|
// anyway.
|
|
|
|
bool failed = false;
|
2000-11-08 09:39:46 +00:00
|
|
|
|
2001-01-08 09:37:13 +00:00
|
|
|
string const tmp_ret = lyx::tempName(string(), "lyxauto");
|
1999-09-27 18:44:28 +00:00
|
|
|
if (!tmp_ret.empty()) {
|
2000-04-11 22:55:29 +00:00
|
|
|
bv->buffer()->writeFile(tmp_ret, 1);
|
1999-09-27 18:44:28 +00:00
|
|
|
// assume successful write of tmp_ret
|
2001-01-08 09:37:13 +00:00
|
|
|
if (!lyx::rename(tmp_ret, fname)) {
|
1999-09-27 18:44:28 +00:00
|
|
|
failed = true;
|
|
|
|
// most likely couldn't move between filesystems
|
|
|
|
// unless write of tmp_ret failed
|
|
|
|
// so remove tmp file (if it exists)
|
2000-09-26 13:54:57 +00:00
|
|
|
lyx::unlink(tmp_ret);
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
failed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (failed) {
|
|
|
|
// failed to write/rename tmp_ret so try writing direct
|
2000-04-11 22:55:29 +00:00
|
|
|
if (!bv->buffer()->writeFile(fname, 1)) {
|
1999-09-27 18:44:28 +00:00
|
|
|
// It is dangerous to do this in the child,
|
|
|
|
// but safe in the parent, so...
|
|
|
|
if (pid == -1)
|
2000-04-11 22:55:29 +00:00
|
|
|
bv->owner()->getMiniBuffer()->Set(_("Autosave Failed!"));
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pid == 0) { // we are the child so...
|
|
|
|
_exit(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-04-11 22:55:29 +00:00
|
|
|
bv->buffer()->markBakClean();
|
|
|
|
bv->owner()->resetAutosaveTimer();
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
2000-03-09 03:36:48 +00:00
|
|
|
// Copyright CHT Software Service GmbH
|
1999-09-27 18:44:28 +00:00
|
|
|
// Uwe C. Schroeder
|
|
|
|
//
|
|
|
|
// create new file with template
|
|
|
|
// SERVERCMD !
|
|
|
|
//
|
1999-10-02 16:21:10 +00:00
|
|
|
Buffer * NewLyxFile(string const & filename)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
|
|
|
// Split argument by :
|
1999-10-02 16:21:10 +00:00
|
|
|
string name;
|
1999-11-01 04:22:28 +00:00
|
|
|
string tmpname = split(filename, name, ':');
|
1999-09-27 18:44:28 +00:00
|
|
|
#ifdef __EMX__ // Fix me! lyx_cb.C may not be low level enough to allow this.
|
1999-11-01 04:22:28 +00:00
|
|
|
if (name.length() == 1
|
|
|
|
&& isalpha(static_cast<unsigned char>(name[0]))
|
|
|
|
&& (prefixIs(tmpname, "/") || prefixIs(tmpname, "\\"))) {
|
1999-09-27 18:44:28 +00:00
|
|
|
name += ':';
|
1999-11-01 04:22:28 +00:00
|
|
|
name += token(tmpname, ':', 0);
|
|
|
|
tmpname = split(tmpname, ':');
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
#endif
|
1999-10-07 18:44:17 +00:00
|
|
|
lyxerr.debug() << "Arg is " << filename
|
|
|
|
<< "\nName is " << name
|
|
|
|
<< "\nTemplate is " << tmpname << endl;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
// find a free buffer
|
1999-11-26 06:57:35 +00:00
|
|
|
Buffer * tmpbuf = bufferlist.newFile(name, tmpname);
|
1999-09-27 18:44:28 +00:00
|
|
|
if (tmpbuf)
|
1999-12-10 00:07:59 +00:00
|
|
|
lastfiles->newFile(tmpbuf->fileName());
|
1999-09-27 18:44:28 +00:00
|
|
|
return tmpbuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Insert ascii file (if filename is empty, prompt for one)
|
2000-03-17 10:14:46 +00:00
|
|
|
void InsertAsciiFile(BufferView * bv, string const & f, bool asParagraph)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
1999-10-02 16:21:10 +00:00
|
|
|
string fname = f;
|
1999-09-27 18:44:28 +00:00
|
|
|
LyXFileDlg fileDlg;
|
|
|
|
|
2000-03-17 10:14:46 +00:00
|
|
|
if (!bv->available()) return;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
if (fname.empty()) {
|
2000-04-11 22:55:29 +00:00
|
|
|
ProhibitInput(bv);
|
1999-09-27 18:44:28 +00:00
|
|
|
fname = fileDlg.Select(_("File to Insert"),
|
2000-03-17 10:14:46 +00:00
|
|
|
bv->owner()->buffer()->filepath,
|
1999-09-27 18:44:28 +00:00
|
|
|
"*");
|
2000-04-11 22:55:29 +00:00
|
|
|
AllowInput(bv);
|
1999-09-27 18:44:28 +00:00
|
|
|
if (fname.empty()) return;
|
|
|
|
}
|
|
|
|
|
|
|
|
FileInfo fi(fname);
|
|
|
|
|
1999-11-24 22:14:46 +00:00
|
|
|
if (!fi.readable()) {
|
|
|
|
WriteFSAlert(_("Error! Specified file is unreadable: "),
|
1999-11-15 12:01:38 +00:00
|
|
|
MakeDisplayPath(fname, 50));
|
1999-09-27 18:44:28 +00:00
|
|
|
return;
|
|
|
|
}
|
1999-11-24 22:14:46 +00:00
|
|
|
|
2000-01-06 02:44:26 +00:00
|
|
|
ifstream ifs(fname.c_str());
|
|
|
|
if (!ifs) {
|
1999-11-24 22:14:46 +00:00
|
|
|
WriteFSAlert(_("Error! Cannot open specified file: "),
|
|
|
|
MakeDisplayPath(fname, 50));
|
|
|
|
return;
|
|
|
|
}
|
1999-11-15 12:01:38 +00:00
|
|
|
|
2000-03-28 02:18:55 +00:00
|
|
|
ifs.unsetf(ios::skipws);
|
|
|
|
istream_iterator<char> ii(ifs);
|
|
|
|
istream_iterator<char> end;
|
2000-07-24 21:49:58 +00:00
|
|
|
#if !defined(USE_INCLUDED_STRING) && !defined(STD_STRING_IS_GOOD)
|
|
|
|
// We use this until the compilers get better...
|
|
|
|
vector<char> tmp;
|
|
|
|
copy(ii, end, back_inserter(tmp));
|
2000-12-06 22:24:17 +00:00
|
|
|
string const tmpstr(tmp.begin(), tmp.end());
|
2000-07-24 21:49:58 +00:00
|
|
|
#else
|
|
|
|
// This is what we want to use and what we will use once the
|
|
|
|
// compilers get good enough.
|
2000-03-17 10:14:46 +00:00
|
|
|
//string tmpstr(ii, end); // yet a reason for using std::string
|
2000-03-16 04:29:22 +00:00
|
|
|
// alternate approach to get the file into a string:
|
2000-03-17 10:14:46 +00:00
|
|
|
string tmpstr;
|
|
|
|
copy(ii, end, back_inserter(tmpstr));
|
2000-07-24 21:49:58 +00:00
|
|
|
#endif
|
1999-09-27 18:44:28 +00:00
|
|
|
// insert the string
|
2000-09-26 13:54:57 +00:00
|
|
|
bv->hideCursor();
|
1999-11-26 06:57:35 +00:00
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
// clear the selection
|
2001-02-14 10:11:22 +00:00
|
|
|
bv->beforeChange(bv->text);
|
1999-12-10 00:07:59 +00:00
|
|
|
if (!asParagraph)
|
2000-06-12 11:27:15 +00:00
|
|
|
bv->text->InsertStringA(bv, tmpstr);
|
1999-12-10 00:07:59 +00:00
|
|
|
else
|
2000-06-12 11:27:15 +00:00
|
|
|
bv->text->InsertStringB(bv, tmpstr);
|
2001-02-14 08:38:21 +00:00
|
|
|
bv->update(bv->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-11-14 02:01:57 +00:00
|
|
|
void MenuInsertLabel(BufferView * bv, string const & arg)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2000-09-14 17:53:12 +00:00
|
|
|
string label(arg);
|
2000-11-14 02:01:57 +00:00
|
|
|
ProhibitInput(bv);
|
1999-12-30 02:35:43 +00:00
|
|
|
if (label.empty()) {
|
2000-12-11 09:46:09 +00:00
|
|
|
#ifndef NEW_INSETS
|
|
|
|
LyXParagraph * par =
|
|
|
|
bv->text->cursor.par()->FirstPhysicalPar();
|
|
|
|
#else
|
|
|
|
LyXParagraph * par = bv->text->cursor.par();
|
|
|
|
#endif
|
|
|
|
LyXLayout const * layout =
|
|
|
|
&textclasslist.Style(bv->buffer()->params.textclass,
|
|
|
|
par->GetLayout());
|
|
|
|
|
|
|
|
if (layout->latextype == LATEX_PARAGRAPH && par->previous) {
|
|
|
|
#ifndef NEW_INSETS
|
|
|
|
LyXParagraph * par2 = par->previous->FirstPhysicalPar();
|
|
|
|
#else
|
|
|
|
LyXParagraph * par2 = par->previous;
|
|
|
|
#endif
|
|
|
|
LyXLayout const * layout2 =
|
|
|
|
&textclasslist.Style(bv->buffer()->params.textclass,
|
|
|
|
par2->GetLayout());
|
|
|
|
if (layout2->latextype != LATEX_PARAGRAPH) {
|
|
|
|
par = par2;
|
|
|
|
layout = layout2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
string text = layout->latexname().substr(0, 3);
|
|
|
|
if (layout->latexname() == "theorem")
|
|
|
|
text = "thm"; // Create a correct prefix for prettyref
|
|
|
|
#ifndef NEW_INSETS
|
|
|
|
if (par->footnoteflag==LyXParagraph::OPEN_FOOTNOTE)
|
|
|
|
switch (par->footnotekind) {
|
|
|
|
case LyXParagraph::FIG:
|
|
|
|
case LyXParagraph::WIDE_FIG:
|
|
|
|
text = "fig";
|
|
|
|
break;
|
|
|
|
case LyXParagraph::TAB:
|
|
|
|
case LyXParagraph::WIDE_TAB:
|
|
|
|
text = "tab";
|
|
|
|
break;
|
|
|
|
case LyXParagraph::ALGORITHM:
|
|
|
|
text = "alg";
|
|
|
|
break;
|
|
|
|
case LyXParagraph::FOOTNOTE:
|
|
|
|
case LyXParagraph::MARGIN:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
text += ":";
|
|
|
|
if (layout->latextype == LATEX_PARAGRAPH ||
|
|
|
|
lyxrc.label_init_length < 0)
|
|
|
|
text.erase();
|
|
|
|
string par_text = par->String(bv->buffer(), false);
|
|
|
|
for (int i = 0; i < lyxrc.label_init_length; ++i) {
|
|
|
|
if (par_text.empty())
|
|
|
|
break;
|
|
|
|
string head;
|
|
|
|
par_text = split(par_text, head, ' ');
|
|
|
|
if (i > 0)
|
2001-01-15 13:31:25 +00:00
|
|
|
text += '-'; // Is it legal to use spaces in
|
2000-12-11 09:46:09 +00:00
|
|
|
// labels ?
|
|
|
|
text += head;
|
|
|
|
}
|
|
|
|
|
|
|
|
pair<bool, string> result =
|
|
|
|
askForText(_("Enter new label to insert:"), text);
|
1999-12-30 02:35:43 +00:00
|
|
|
if (result.first) {
|
|
|
|
label = frontStrip(strip(result.second));
|
|
|
|
}
|
|
|
|
}
|
1999-09-27 18:44:28 +00:00
|
|
|
if (!label.empty()) {
|
2000-08-04 13:12:30 +00:00
|
|
|
InsetCommandParams p( "label", label );
|
|
|
|
InsetLabel * inset = new InsetLabel( p );
|
2000-11-14 02:01:57 +00:00
|
|
|
bv->insertInset( inset );
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
2000-11-14 02:01:57 +00:00
|
|
|
AllowInput(bv);
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-09-26 13:54:57 +00:00
|
|
|
// This is _only_ used in Toolbar_pimpl.C, move it there and get rid of
|
|
|
|
// current_view. (Lgb)
|
2000-09-14 14:37:21 +00:00
|
|
|
void LayoutsCB(int sel, void *, Combox *)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2000-11-14 02:01:57 +00:00
|
|
|
string const tmp = tostr(sel);
|
1999-11-09 23:52:04 +00:00
|
|
|
current_view->owner()->getLyXFunc()->Dispatch(LFUN_LAYOUTNO,
|
2000-09-19 11:18:35 +00:00
|
|
|
tmp);
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-11-14 02:01:57 +00:00
|
|
|
void MenuLayoutSave(BufferView * bv)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2000-11-14 02:01:57 +00:00
|
|
|
if (!bv->available())
|
1999-12-16 06:43:25 +00:00
|
|
|
return;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
if (AskQuestion(_("Do you want to save the current settings"),
|
|
|
|
_("for Character, Document, Paper and Quotes"),
|
|
|
|
_("as default for new documents?")))
|
2000-11-14 02:01:57 +00:00
|
|
|
bv->buffer()->saveParamsAsDefaults();
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-04-12 14:20:08 +00:00
|
|
|
void Figure()
|
|
|
|
{
|
|
|
|
if (fd_form_figure->form_figure->visible) {
|
|
|
|
fl_raise_form(fd_form_figure->form_figure);
|
|
|
|
} else {
|
|
|
|
fl_show_form(fd_form_figure->form_figure,
|
2000-11-08 09:39:46 +00:00
|
|
|
FL_PLACE_MOUSE | FL_FREE_SIZE, FL_TRANSIENT,
|
2000-04-12 14:20:08 +00:00
|
|
|
_("Insert Figure"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
/* callbacks for form form_figure */
|
2000-07-19 17:16:27 +00:00
|
|
|
extern "C"
|
|
|
|
void FigureApplyCB(FL_OBJECT *, long)
|
1999-12-10 00:07:59 +00:00
|
|
|
{
|
|
|
|
if (!current_view->available())
|
|
|
|
return;
|
|
|
|
|
|
|
|
Buffer * buffer = current_view->buffer();
|
2000-11-04 10:00:12 +00:00
|
|
|
if (buffer->isReadonly()) // paranoia
|
1999-12-10 00:07:59 +00:00
|
|
|
return;
|
|
|
|
|
1999-12-19 22:35:36 +00:00
|
|
|
current_view->owner()->getMiniBuffer()->Set(_("Inserting figure..."));
|
2000-09-23 04:57:18 +00:00
|
|
|
if (fl_get_button(fd_form_figure->radio_inline)) {
|
2000-10-10 11:50:43 +00:00
|
|
|
InsetFig * new_inset = new InsetFig(100, 20, *buffer);
|
2000-01-08 21:02:58 +00:00
|
|
|
current_view->insertInset(new_inset);
|
1999-12-19 22:35:36 +00:00
|
|
|
current_view->owner()->getMiniBuffer()->Set(_("Figure inserted"));
|
2000-02-25 12:06:15 +00:00
|
|
|
new_inset->Edit(current_view, 0, 0, 0);
|
1999-12-10 00:07:59 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2000-02-17 19:59:08 +00:00
|
|
|
current_view->hideCursor();
|
2001-02-14 08:38:21 +00:00
|
|
|
current_view->update(current_view->text, BufferView::SELECT|BufferView::FITCUR);
|
2001-02-14 10:11:22 +00:00
|
|
|
current_view->beforeChange(current_view->text);
|
1999-12-10 00:07:59 +00:00
|
|
|
|
2000-06-12 11:27:15 +00:00
|
|
|
current_view->text->SetCursorParUndo(current_view->buffer());
|
1999-12-10 00:07:59 +00:00
|
|
|
current_view->text->FreezeUndo();
|
|
|
|
|
2000-06-12 11:27:15 +00:00
|
|
|
current_view->text->BreakParagraph(current_view);
|
2001-02-14 08:38:21 +00:00
|
|
|
current_view->update(current_view->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
|
1999-12-10 00:07:59 +00:00
|
|
|
|
2000-06-08 23:16:16 +00:00
|
|
|
if (current_view->text->cursor.par()->Last()) {
|
2000-06-12 11:27:15 +00:00
|
|
|
current_view->text->CursorLeft(current_view);
|
1999-12-10 00:07:59 +00:00
|
|
|
|
2000-06-12 11:27:15 +00:00
|
|
|
current_view->text->BreakParagraph(current_view);
|
2001-02-14 08:38:21 +00:00
|
|
|
current_view->update(current_view->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
|
1999-12-10 00:07:59 +00:00
|
|
|
}
|
1999-09-27 18:44:28 +00:00
|
|
|
|
1999-12-10 00:07:59 +00:00
|
|
|
// The standard layout should always be numer 0;
|
2000-06-12 11:27:15 +00:00
|
|
|
current_view->text->SetLayout(current_view, 0);
|
2000-07-19 17:16:27 +00:00
|
|
|
|
|
|
|
#ifndef NEW_INSETS
|
2000-06-08 23:16:16 +00:00
|
|
|
if (current_view->text->cursor.par()->footnoteflag ==
|
1999-12-10 00:07:59 +00:00
|
|
|
LyXParagraph::NO_FOOTNOTE) {
|
2000-07-19 17:16:27 +00:00
|
|
|
#endif
|
1999-12-10 00:07:59 +00:00
|
|
|
current_view->text->
|
2000-06-12 11:27:15 +00:00
|
|
|
SetParagraph(current_view, 0, 0,
|
1999-12-10 00:07:59 +00:00
|
|
|
0, 0,
|
|
|
|
VSpace (0.3 * buffer->params.spacing.getValue(),
|
|
|
|
LyXLength::CM),
|
|
|
|
VSpace (0.3 *
|
|
|
|
buffer->params.spacing.getValue(),
|
|
|
|
LyXLength::CM),
|
|
|
|
LYX_ALIGN_CENTER, string(), 0);
|
2000-07-19 17:16:27 +00:00
|
|
|
#ifndef NEW_INSETS
|
2000-02-04 09:38:32 +00:00
|
|
|
} else {
|
2000-06-12 11:27:15 +00:00
|
|
|
current_view->text->SetParagraph(current_view, 0, 0,
|
1999-12-16 06:43:25 +00:00
|
|
|
0, 0,
|
|
|
|
VSpace(VSpace::NONE),
|
|
|
|
VSpace(VSpace::NONE),
|
|
|
|
LYX_ALIGN_CENTER,
|
|
|
|
string(),
|
|
|
|
0);
|
2000-02-04 09:38:32 +00:00
|
|
|
}
|
2000-07-19 17:16:27 +00:00
|
|
|
#endif
|
1999-12-10 00:07:59 +00:00
|
|
|
|
2001-02-14 08:38:21 +00:00
|
|
|
current_view->update(current_view->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
|
1999-12-10 00:07:59 +00:00
|
|
|
|
2000-10-10 11:50:43 +00:00
|
|
|
Inset * new_inset = new InsetFig(100, 100, *buffer);
|
2000-01-08 21:02:58 +00:00
|
|
|
current_view->insertInset(new_inset);
|
2000-02-25 12:06:15 +00:00
|
|
|
new_inset->Edit(current_view, 0, 0, 0);
|
2001-02-14 08:38:21 +00:00
|
|
|
current_view->update(current_view->text, BufferView::SELECT|BufferView::FITCUR);
|
1999-12-19 22:35:36 +00:00
|
|
|
current_view->owner()->getMiniBuffer()->Set(_("Figure inserted"));
|
1999-12-10 00:07:59 +00:00
|
|
|
current_view->text->UnFreezeUndo();
|
2000-02-17 19:59:08 +00:00
|
|
|
current_view->setState();
|
1999-12-10 00:07:59 +00:00
|
|
|
}
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
|
1999-10-19 15:06:30 +00:00
|
|
|
extern "C" void FigureCancelCB(FL_OBJECT *, long)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
|
|
|
fl_hide_form(fd_form_figure->form_figure);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-11-26 06:57:35 +00:00
|
|
|
extern "C" void FigureOKCB(FL_OBJECT * ob, long data)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
1999-11-15 12:01:38 +00:00
|
|
|
FigureApplyCB(ob, data);
|
|
|
|
FigureCancelCB(ob, data);
|
1999-09-27 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
1999-11-26 06:57:35 +00:00
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
// This function runs "configure" and then rereads lyx.defaults to
|
|
|
|
// reconfigure the automatic settings.
|
2000-02-04 09:38:32 +00:00
|
|
|
void Reconfigure(BufferView * bv)
|
1999-09-27 18:44:28 +00:00
|
|
|
{
|
2000-02-04 09:38:32 +00:00
|
|
|
bv->owner()->getMiniBuffer()->Set(_("Running configure..."));
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
// Run configure in user lyx directory
|
1999-10-13 17:32:46 +00:00
|
|
|
Path p(user_lyxdir);
|
1999-09-27 18:44:28 +00:00
|
|
|
Systemcalls one(Systemcalls::System,
|
1999-12-16 06:43:25 +00:00
|
|
|
AddName(system_lyxdir, "configure"));
|
1999-10-13 17:32:46 +00:00
|
|
|
p.pop();
|
2000-02-04 09:38:32 +00:00
|
|
|
bv->owner()->getMiniBuffer()->Set(_("Reloading configuration..."));
|
2000-03-12 10:35:05 +00:00
|
|
|
lyxrc.read(LibFileSearch(string(), "lyxrc.defaults"));
|
1999-09-27 18:44:28 +00:00
|
|
|
WriteAlert(_("The system has been reconfigured."),
|
|
|
|
_("You need to restart LyX to make use of any"),
|
|
|
|
_("updated document class specifications."));
|
|
|
|
}
|