* LyX, The Document Processor
*
* Copyright 1995 Matthias Ettrich
- * Copyright 1995-2000 The LyX Team.
+ * Copyright 1995-2001 The LyX Team.
*
* ====================================================== */
#include "bufferview_funcs.h"
#include "LaTeX.h"
#include "LyXView.h"
-#include "minibuffer.h"
#include "lyx_gui_misc.h"
#include "lyx_cb.h" // ShowMessage()
#include "support/lyxfunctional.h"
+#include "gettext.h"
+#include "BufferView.h"
using std::vector;
using std::queue;
using std::reverse;
using std::sort;
-static string const token_from("$$i");
-static string const token_base("$$b");
-static string const token_to("$$o");
+namespace {
+
+string const token_from("$$i");
+string const token_base("$$b");
+string const token_to("$$o");
//////////////////////////////////////////////////////////////////////////////
-static inline
+inline
string const add_options(string const & command, string const & options)
{
string head;
return head + ' ' + options + ' ' + tail;
}
+} // namespace anon
+
//////////////////////////////////////////////////////////////////////////////
bool Format::dummy() const
{
FormatList::const_iterator cit =
find_if(formatlist.begin(), formatlist.end(),
- compare_memfun(&Format::name, name));
+ lyx::compare_memfun(&Format::name, name));
if (cit != formatlist.end())
return &(*cit);
else
{
FormatList::const_iterator cit =
find_if(formatlist.begin(), formatlist.end(),
- compare_memfun(&Format::name, name));
+ lyx::compare_memfun(&Format::name, name));
if (cit != formatlist.end())
return cit - formatlist.begin();
else
{
FormatList::iterator it =
find_if(formatlist.begin(), formatlist.end(),
- compare_memfun(&Format::name, name));
+ lyx::compare_memfun(&Format::name, name));
if (it == formatlist.end())
formatlist.push_back(Format(name, extension, prettyname,
shortcut, ""));
{
FormatList::iterator it =
find_if(formatlist.begin(), formatlist.end(),
- compare_memfun(&Format::name, name));
+ lyx::compare_memfun(&Format::name, name));
if (it != formatlist.end())
formatlist.erase(it);
}
Add(name);
FormatList::iterator it =
find_if(formatlist.begin(), formatlist.end(),
- compare_memfun(&Format::name, name));
+ lyx::compare_memfun(&Format::name, name));
if (it != formatlist.end())
it->setViewer(command);
}
if (format_name == "dvi" &&
!lyxrc.view_dvi_paper_option.empty()) {
command += " " + lyxrc.view_dvi_paper_option;
- command += " " + converters.dvi_papersize(buffer);
+ string paper_size = converters.papersize(buffer);
+ if (paper_size == "letter")
+ paper_size = "us";
+ command += " " + paper_size;
if (buffer->params.orientation
== BufferParams::ORIENTATION_LANDSCAPE)
command += 'r';
}
- string command2 = command + " " + OnlyFilename(filename);
- lyxerr << "Executing command: " << command2 << endl;
- ShowMessage(buffer, _("Executing command:"), command2);
+ command += " " + QuoteName(OnlyFilename((filename)));
- command += " " + QuoteName(filename);
+ lyxerr[Debug::FILES] << "Executing command: " << command << endl;
+ ShowMessage(buffer, _("Executing command:"), command);
+
+ Path p(OnlyPath(filename));
Systemcalls one;
- int res = one.startscript(Systemcalls::SystemDontWait, command);
+ int const res = one.startscript(Systemcalls::SystemDontWait, command);
if (res) {
WriteAlert(_("Can not view file"),
_("Error while executing"),
- command2.substr(0, 50));
+ command.substr(0, 50));
return false;
}
return true;
bool operator<(Converter const & a, Converter const & b)
{
- int i = compare_no_case(a.From->prettyname(), b.From->prettyname());
+ int const i = compare_no_case(a.From->prettyname(),
+ b.From->prettyname());
if (i == 0)
return compare_no_case(a.To->prettyname(), b.To->prettyname())
< 0;
return c.from == from && c.to == to;
}
private:
- string from;
- string to;
+ string const & from;
+ string const & to;
};
converter.ReadFlags();
if (converter.latex && (latex_command.empty() || to == "dvi"))
- latex_command = command;
+ latex_command = subst(command, token_from, "");
// If we have both latex & pdflatex, we set latex_command to latex.
// The latex_command is used to update the .aux file when running
// a converter that uses it.
int Converters::BFS_init(string const & start, bool clear_visited)
{
- int s = formats.GetNumber(start);
+ int const s = formats.GetNumber(start);
if (s < 0)
return s;
Converters::GetReachableTo(string const & target, bool clear_visited)
{
vector<Format const *> result;
- int s = BFS_init(target, clear_visited);
+ int const s = BFS_init(target, clear_visited);
if (s < 0)
return result;
while (!Q.empty()) {
- int i = Q.front();
+ int const i = Q.front();
Q.pop();
if (i != s || target != "lyx")
result.push_back(&formats.Get(i));
return result;
while (!Q.empty()) {
- int i = Q.front();
+ int const i = Q.front();
Q.pop();
Format const & format = formats.Get(i);
if (format.name() == "lyx")
if (from == to)
return true;
- int s = BFS_init(from);
- int t = formats.GetNumber(to);
+ int const s = BFS_init(from);
+ int const t = formats.GetNumber(to);
if (s < 0 || t < 0)
return false;
while (!Q.empty()) {
- int i = Q.front();
+ int const i = Q.front();
Q.pop();
if (i == t)
return true;
if (from == to)
return path;
- int s = BFS_init(from);
+ int const s = BFS_init(from);
int t = formats.GetNumber(to);
if (s < 0 || t < 0)
return path;
bool found = false;
while (!Q.empty()) {
- int i = Q.front();
+ int const i = Q.front();
Q.pop();
if (i == t) {
found = true;
for (vector<int>::iterator it = vertices[i].out_vertices.begin();
it != vertices[i].out_vertices.end(); ++it)
if (!visited[*it]) {
- int j = *it;
+ int const j = *it;
visited[j] = true;
Q.push(j);
- int k = it - vertices[i].out_vertices.begin();
+ int const k = it - vertices[i].out_vertices.begin();
prev_edge[j] = vertices[i].out_edges[k];
prev_vertex[j] = i;
}
formats.Extension(to_format));
if (from_format == to_format)
- if (from_file != to_file)
- return lyx::rename(from_file, to_file);
- else
- return true;
+ return Move(from_file, to_file, false);
EdgePath edgepath = GetPath(from_format, to_format);
if (edgepath.empty()) {
Converter const & conv = converterlist[*cit];
bool dummy = conv.To->dummy() && conv.to != "program";
if (!dummy)
- lyxerr << "Converting from "
+ lyxerr[Debug::FILES] << "Converting from "
<< conv.from << " to " << conv.to << endl;
infile = outfile;
outfile = conv.result_dir.empty()
if (conv.latex) {
run_latex = true;
string command = subst(conv.command, token_from, "");
- lyxerr << "Running " << command << endl;
+ lyxerr[Debug::FILES] << "Running " << command << endl;
if (!runLaTeX(buffer, command))
return false;
} else {
if (conv.need_aux && !run_latex
&& !latex_command.empty()) {
- lyxerr << "Running " << latex_command
- << " to update aux file"<< endl;
+ lyxerr[Debug::FILES]
+ << "Running " << latex_command
+ << " to update aux file"<< endl;
runLaTeX(buffer, latex_command);
}
if (conv.from == "dvi" && conv.to == "ps")
command = add_options(command,
dvips_options(buffer));
+ else if (conv.from == "dvi" && prefixIs(conv.to, "pdf"))
+ command = add_options(command,
+ dvipdfm_options(buffer));
- lyxerr << "Calling " << command << endl;
+ lyxerr[Debug::FILES] << "Calling " << command << endl;
if (buffer)
ShowMessage(buffer, _("Executing command:"), command);
return false;
}
}
- } else if (outfile != to_file) {
- bool moved = (conv.latex)
- ? lyx::copy(outfile, to_file)
- : lyx::rename(outfile, to_file);
- if (!moved) {
- WriteAlert(_("Error while trying to move file:"),
- outfile, _("to ") + to_file);
- return false;
- }
- }
-
- return true;
+ return true;
+ } else
+ return Move(outfile, to_file, conv.latex);
}
+// If from = /path/file.ext and to = /path2/file2.ext2 then this method
+// moves each /path/file*.ext file to /path2/file2*.ext2'
+bool Converters::Move(string const & from, string const & to, bool copy)
+{
+ if (from == to)
+ return true;
+
+ bool no_errors = true;
+ string const path = OnlyPath(from);
+ string const base = OnlyFilename(ChangeExtension(from, ""));
+ string const to_base = ChangeExtension(to, "");
+ string const to_extension = GetExtension(to);
+
+ vector<string> files = DirList(OnlyPath(from), GetExtension(from));
+ for (vector<string>::const_iterator it = files.begin();
+ it != files.end(); ++it)
+ if (prefixIs(*it, base)) {
+ string from2 = path + *it;
+ string to2 = to_base + it->substr(base.length());
+ to2 = ChangeExtension(to2, to_extension);
+ lyxerr[Debug::FILES] << "moving " << from2
+ << " to " << to2 << endl;
+ bool moved = (copy)
+ ? lyx::copy(from2, to2)
+ : lyx::rename(from2, to2);
+ if (!moved && no_errors) {
+ WriteAlert(_("Error while trying to move file:"),
+ from2, _("to ") + to2);
+ no_errors = false;
+ }
+ }
+ return no_errors;
+}
bool Converters::Convert(Buffer const * buffer,
string const & from_file, string const & to_file_base,
}
+
void Converters::BuildGraph()
{
vertices = vector<Vertex>(formats.size());
for (ConverterList::iterator it = converterlist.begin();
it != converterlist.end(); ++it) {
- int s = formats.GetNumber(it->from);
- int t = formats.GetNumber(it->to);
+ int const s = formats.GetNumber(it->from);
+ int const t = formats.GetNumber(it->to);
vertices[t].in_vertices.push_back(s);
vertices[s].out_vertices.push_back(t);
vertices[s].out_edges.push_back(it - converterlist.begin());
BufferView * bv = buffer->getUser();
bool need_redraw = false;
if (bv) {
- ProhibitInput(bv);
+ bv->owner()->prohibitInput();
// Remove all error insets
need_redraw = bv->removeAutoInsets();
}
bv->redraw();
bv->fitCursor(bv->text);
}
- AllowInput(bv);
+ bv->owner()->allowInput();
}
if ((result & LaTeX::ERRORS)) {
bool need_redraw = false;
if (bv) {
- ProhibitInput(bv);
- bv->owner()->getMiniBuffer()->Set(_("Running LaTeX..."));
+ bv->owner()->prohibitInput();
+ bv->owner()->message(_("Running LaTeX..."));
// Remove all error insets
need_redraw = bv->removeAutoInsets();
}
TeXErrors terr;
LaTeX latex(command, name, buffer->filepath);
int result = latex.run(terr,
- bv ? bv->owner()->getMiniBuffer() : 0);
+ bv ? bv->owner()->getLyXFunc() : 0);
if (bv) {
}
if (bv)
- AllowInput(bv);
+ bv->owner()->allowInput();
int const ERROR_MASK =
LaTeX::NO_LOGFILE |
}
-string const Converters::dvi_papersize(Buffer const * buffer)
+string const Converters::papersize(Buffer const * buffer)
{
char real_papersize = buffer->params.papersize;
if (real_papersize == BufferParams::PAPER_DEFAULT)
return "legal";
case BufferParams::PAPER_USLETTER:
default:
- return "us";
+ return "letter";
}
}
result += ' ' + buffer->params.paperwidth;
result += ',' + buffer->params.paperheight;
} else {
- string paper_option = dvi_papersize(buffer);
- if (paper_option == "us")
- paper_option = "letter";
+ string paper_option = papersize(buffer);
if (paper_option != "letter" ||
buffer->params.orientation != BufferParams::ORIENTATION_LANDSCAPE) {
// dvips won't accept -t letter -t landscape. In all other
result += ' ' + paper_option;
}
}
- if (buffer->params.orientation == BufferParams::ORIENTATION_LANDSCAPE)
+ if (buffer->params.orientation == BufferParams::ORIENTATION_LANDSCAPE &&
+ buffer->params.papersize2 != BufferParams::VM_PAPER_CUSTOM)
result += ' ' + lyxrc.print_landscape_flag;
return result;
}
+
+string const Converters::dvipdfm_options(Buffer const * buffer)
+{
+ string result;
+ if (!buffer)
+ return result;
+
+ if (buffer->params.papersize2 != BufferParams::VM_PAPER_CUSTOM) {
+ string paper_size = papersize(buffer);
+ if (paper_size != "b5" && paper_size != "foolscap")
+ result = "-p "+ paper_size;
+
+ if (buffer->params.orientation == BufferParams::ORIENTATION_LANDSCAPE)
+ result += " -l";
+ }
+
+ return result;
+}
+
+
vector<Converters::Vertex> Converters::vertices;
projects / lyx.git / blobdiff