src/insets/InsetInclude.cpp

   1 /**
   2  * \file InsetInclude.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Lars Gullik Bjønnes
   7  * \author Richard Heck (conversion to InsetCommand)
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "InsetInclude.h"
  15
  16 #include "Buffer.h"
  17 #include "buffer_funcs.h"
  18 #include "BufferList.h"
  19 #include "BufferParams.h"
  20 #include "BufferView.h"
  21 #include "Converter.h"
  22 #include "Cursor.h"
  23 #include "DispatchResult.h"
  24 #include "Encoding.h"
  25 #include "ErrorList.h"
  26 #include "Exporter.h"
  27 #include "Format.h"
  28 #include "FuncRequest.h"
  29 #include "FuncStatus.h"
  30 #include "LaTeXFeatures.h"
  31 #include "LayoutFile.h"
  32 #include "LayoutModuleList.h"
  33 #include "LyX.h"
  34 #include "Lexer.h"
  35 #include "MetricsInfo.h"
  36 #include "output_plaintext.h"
  37 #include "output_xhtml.h"
  38 #include "OutputParams.h"
  39 #include "texstream.h"
  40 #include "TextClass.h"
  41 #include "TocBackend.h"
  42
  43 #include "frontends/alert.h"
  44 #include "frontends/Painter.h"
  45
  46 #include "graphics/PreviewImage.h"
  47 #include "graphics/PreviewLoader.h"
  48
  49 #include "insets/InsetLabel.h"
  50 #include "insets/InsetListingsParams.h"
  51 #include "insets/RenderPreview.h"
  52
  53 #include "mathed/MacroTable.h"
  54
  55 #include "support/convert.h"
  56 #include "support/debug.h"
  57 #include "support/docstream.h"
  58 #include "support/FileNameList.h"
  59 #include "support/filetools.h"
  60 #include "support/gettext.h"
  61 #include "support/lassert.h"
  62 #include "support/lstrings.h" // contains
  63 #include "support/lyxalgo.h"
  64 #include "support/mutex.h"
  65 #include "support/ExceptionMessage.h"
  66
  67 #include "support/bind.h"
  68
  69 using namespace std;
  70 using namespace lyx::support;
  71
  72 namespace lyx {
  73
  74 namespace Alert = frontend::Alert;
  75
  76
  77 namespace {
  78
  79 docstring const uniqueID()
  80 {
  81         static unsigned int seed = 1000;
  82         static Mutex mutex;
  83         Mutex::Locker lock(&mutex);
  84         return "file" + convert<docstring>(++seed);
  85 }
  86
  87
  88 /// the type of inclusion
  89 enum Types {
  90         INCLUDE, VERB, INPUT, VERBAST, LISTINGS, NONE
  91 };
  92
  93
  94 Types type(string const & s)
  95 {
  96         if (s == "input")
  97                 return INPUT;
  98         if (s == "verbatiminput")
  99                 return VERB;
 100         if (s == "verbatiminput*")
 101                 return VERBAST;
 102         if (s == "lstinputlisting")
 103                 return LISTINGS;
 104         if (s == "include")
 105                 return INCLUDE;
 106         return NONE;
 107 }
 108
 109
 110 Types type(InsetCommandParams const & params)
 111 {
 112         return type(params.getCmdName());
 113 }
 114
 115
 116 bool isListings(InsetCommandParams const & params)
 117 {
 118         return type(params) == LISTINGS;
 119 }
 120
 121
 122 bool isVerbatim(InsetCommandParams const & params)
 123 {
 124         Types const t = type(params);
 125         return t == VERB || t == VERBAST;
 126 }
 127
 128
 129 bool isInputOrInclude(InsetCommandParams const & params)
 130 {
 131         Types const t = type(params);
 132         return t == INPUT || t == INCLUDE;
 133 }
 134
 135
 136 FileName const masterFileName(Buffer const & buffer)
 137 {
 138         return buffer.masterBuffer()->fileName();
 139 }
 140
 141
 142 void add_preview(RenderMonitoredPreview &, InsetInclude const &, Buffer const &);
 143
 144
 145 string const parentFileName(Buffer const & buffer)
 146 {
 147         return buffer.absFileName();
 148 }
 149
 150
 151 FileName const includedFileName(Buffer const & buffer,
 152                               InsetCommandParams const & params)
 153 {
 154         return makeAbsPath(to_utf8(params["filename"]),
 155                         onlyPath(parentFileName(buffer)));
 156 }
 157
 158
 159 InsetLabel * createLabel(Buffer * buf, docstring const & label_str)
 160 {
 161         if (label_str.empty())
 162                 return 0;
 163         InsetCommandParams icp(LABEL_CODE);
 164         icp["name"] = label_str;
 165         return new InsetLabel(buf, icp);
 166 }
 167
 168 } // namespace anon
 169
 170
 171 InsetInclude::InsetInclude(Buffer * buf, InsetCommandParams const & p)
 172         : InsetCommand(buf, p), include_label(uniqueID()),
 173           preview_(make_unique<RenderMonitoredPreview>(this)), failedtoload_(false),
 174           set_label_(false), label_(0), child_buffer_(0)
 175 {
 176         preview_->connect([=](){ fileChanged(); });
 177
 178         if (isListings(params())) {
 179                 InsetListingsParams listing_params(to_utf8(p["lstparams"]));
 180                 label_ = createLabel(buffer_, from_utf8(listing_params.getParamValue("label")));
 181         } else if (isInputOrInclude(params()) && buf)
 182                 loadIfNeeded();
 183 }
 184
 185
 186 InsetInclude::InsetInclude(InsetInclude const & other)
 187         : InsetCommand(other), include_label(other.include_label),
 188           preview_(make_unique<RenderMonitoredPreview>(this)), failedtoload_(false),
 189           set_label_(false), label_(0), child_buffer_(0)
 190 {
 191         preview_->connect([=](){ fileChanged(); });
 192
 193         if (other.label_)
 194                 label_ = new InsetLabel(*other.label_);
 195 }
 196
 197
 198 InsetInclude::~InsetInclude()
 199 {
 200         if (isBufferLoaded())
 201                 /* Coverity believs that this may throw an exception, but
 202                  * actually this code path is not taken when buffer_ == 0 */
 203                 // coverity[exn_spec_violation]
 204                 buffer().invalidateBibfileCache();
 205         delete label_;
 206 }
 207
 208
 209 void InsetInclude::setBuffer(Buffer & buffer)
 210 {
 211         InsetCommand::setBuffer(buffer);
 212         if (label_)
 213                 label_->setBuffer(buffer);
 214 }
 215
 216
 217 void InsetInclude::setChildBuffer(Buffer * buffer)
 218 {
 219         child_buffer_ = buffer;
 220 }
 221
 222
 223 ParamInfo const & InsetInclude::findInfo(string const & /* cmdName */)
 224 {
 225         // FIXME
 226         // This is only correct for the case of listings, but it'll do for now.
 227         // In the other cases, this second parameter should just be empty.
 228         static ParamInfo param_info_;
 229         if (param_info_.empty()) {
 230                 param_info_.add("filename", ParamInfo::LATEX_REQUIRED);
 231                 param_info_.add("lstparams", ParamInfo::LATEX_OPTIONAL);
 232         }
 233         return param_info_;
 234 }
 235
 236
 237 bool InsetInclude::isCompatibleCommand(string const & s)
 238 {
 239         return type(s) != NONE;
 240 }
 241
 242
 243 void InsetInclude::doDispatch(Cursor & cur, FuncRequest & cmd)
 244 {
 245         switch (cmd.action()) {
 246
 247         case LFUN_INSET_EDIT: {
 248                 editIncluded(to_utf8(params()["filename"]));
 249                 break;
 250         }
 251
 252         case LFUN_INSET_MODIFY: {
 253                 // It should be OK just to invalidate the cache in setParams()
 254                 // If not....
 255                 // child_buffer_ = 0;
 256                 InsetCommandParams p(INCLUDE_CODE);
 257                 if (cmd.getArg(0) == "changetype") {
 258                         cur.recordUndo();
 259                         InsetCommand::doDispatch(cur, cmd);
 260                         p = params();
 261                 } else
 262                         InsetCommand::string2params(to_utf8(cmd.argument()), p);
 263                 if (!p.getCmdName().empty()) {
 264                         if (isListings(p)){
 265                                 InsetListingsParams new_params(to_utf8(p["lstparams"]));
 266                                 docstring const new_label =
 267                                         from_utf8(new_params.getParamValue("label"));
 268
 269                                 if (new_label.empty()) {
 270                                         delete label_;
 271                                         label_ = 0;
 272                                 } else {
 273                                         docstring old_label;
 274                                         if (label_)
 275                                                 old_label = label_->getParam("name");
 276                                         else {
 277                                                 label_ = createLabel(buffer_, new_label);
 278                                                 label_->setBuffer(buffer());
 279                                         }
 280
 281                                         if (new_label != old_label) {
 282                                                 label_->updateLabelAndRefs(new_label, &cur);
 283                                                 // the label might have been adapted (duplicate)
 284                                                 if (new_label != label_->getParam("name")) {
 285                                                         new_params.addParam("label", "{" +
 286                                                                 to_utf8(label_->getParam("name")) + "}", true);
 287                                                         p["lstparams"] = from_utf8(new_params.params());
 288                                                 }
 289                                         }
 290                                 }
 291                         }
 292                         cur.recordUndo();
 293                         setParams(p);
 294                         cur.forceBufferUpdate();
 295                 } else
 296                         cur.noScreenUpdate();
 297                 break;
 298         }
 299
 300         //pass everything else up the chain
 301         default:
 302                 InsetCommand::doDispatch(cur, cmd);
 303                 break;
 304         }
 305 }
 306
 307
 308 void InsetInclude::editIncluded(string const & file)
 309 {
 310         string const ext = support::getExtension(file);
 311         if (ext == "lyx") {
 312                 FuncRequest fr(LFUN_BUFFER_CHILD_OPEN, file);
 313                 lyx::dispatch(fr);
 314         } else
 315                 // tex file or other text file in verbatim mode
 316                 theFormats().edit(buffer(),
 317                         support::makeAbsPath(file, support::onlyPath(buffer().absFileName())),
 318                         "text");
 319 }
 320
 321
 322 bool InsetInclude::getStatus(Cursor & cur, FuncRequest const & cmd,
 323                 FuncStatus & flag) const
 324 {
 325         switch (cmd.action()) {
 326
 327         case LFUN_INSET_EDIT:
 328                 flag.setEnabled(true);
 329                 return true;
 330
 331         case LFUN_INSET_MODIFY:
 332                 if (cmd.getArg(0) == "changetype")
 333                         return InsetCommand::getStatus(cur, cmd, flag);
 334                 else
 335                         flag.setEnabled(true);
 336                 return true;
 337
 338         default:
 339                 return InsetCommand::getStatus(cur, cmd, flag);
 340         }
 341 }
 342
 343
 344 void InsetInclude::setParams(InsetCommandParams const & p)
 345 {
 346         // invalidate the cache
 347         child_buffer_ = 0;
 348
 349         InsetCommand::setParams(p);
 350         set_label_ = false;
 351
 352         if (preview_->monitoring())
 353                 preview_->stopMonitoring();
 354
 355         if (type(params()) == INPUT)
 356                 add_preview(*preview_, *this, buffer());
 357
 358         buffer().invalidateBibfileCache();
 359 }
 360
 361
 362 bool InsetInclude::isChildIncluded() const
 363 {
 364         std::list<std::string> includeonlys =
 365                 buffer().params().getIncludedChildren();
 366         if (includeonlys.empty())
 367                 return true;
 368         return (std::find(includeonlys.begin(),
 369                           includeonlys.end(),
 370                           to_utf8(params()["filename"])) != includeonlys.end());
 371 }
 372
 373
 374 docstring InsetInclude::screenLabel() const
 375 {
 376         docstring temp;
 377
 378         switch (type(params())) {
 379                 case INPUT:
 380                         temp = buffer().B_("Input");
 381                         break;
 382                 case VERB:
 383                         temp = buffer().B_("Verbatim Input");
 384                         break;
 385                 case VERBAST:
 386                         temp = buffer().B_("Verbatim Input*");
 387                         break;
 388                 case INCLUDE:
 389                         if (isChildIncluded())
 390                                 temp = buffer().B_("Include");
 391                         else
 392                                 temp += buffer().B_("Include (excluded)");
 393                         break;
 394                 case LISTINGS:
 395                         temp = listings_label_;
 396                         break;
 397                 case NONE:
 398                         LASSERT(false, temp = buffer().B_("Unknown"));
 399                         break;
 400         }
 401
 402         temp += ": ";
 403
 404         if (params()["filename"].empty())
 405                 temp += "???";
 406         else
 407                 temp += from_utf8(onlyFileName(to_utf8(params()["filename"])));
 408
 409         return temp;
 410 }
 411
 412
 413 Buffer * InsetInclude::getChildBuffer() const
 414 {
 415         Buffer * childBuffer = loadIfNeeded();
 416
 417         // FIXME RECURSIVE INCLUDE
 418         // This isn't sufficient, as the inclusion could be downstream.
 419         // But it'll have to do for now.
 420         return (childBuffer == &buffer()) ? 0 : childBuffer;
 421 }
 422
 423
 424 Buffer * InsetInclude::loadIfNeeded() const
 425 {
 426         // This is for background export and preview. We don't even want to
 427         // try to load the cloned child document again.
 428         if (buffer().isClone())
 429                 return child_buffer_;
 430
 431         // Don't try to load it again if we failed before.
 432         if (failedtoload_ || isVerbatim(params()) || isListings(params()))
 433                 return 0;
 434
 435         FileName const included_file = includedFileName(buffer(), params());
 436         // Use cached Buffer if possible.
 437         if (child_buffer_ != 0) {
 438                 if (theBufferList().isLoaded(child_buffer_)
 439                 // additional sanity check: make sure the Buffer really is
 440                     // associated with the file we want.
 441                     && child_buffer_ == theBufferList().getBuffer(included_file))
 442                         return child_buffer_;
 443                 // Buffer vanished, so invalidate cache and try to reload.
 444                 child_buffer_ = 0;
 445         }
 446
 447         if (!isLyXFileName(included_file.absFileName()))
 448                 return 0;
 449
 450         Buffer * child = theBufferList().getBuffer(included_file);
 451         if (!child) {
 452                 // the readonly flag can/will be wrong, not anymore I think.
 453                 if (!included_file.exists())
 454                         return 0;
 455
 456                 child = theBufferList().newBuffer(included_file.absFileName());
 457                 if (!child)
 458                         // Buffer creation is not possible.
 459                         return 0;
 460
 461                 // Set parent before loading, such that macros can be tracked
 462                 child->setParent(&buffer());
 463
 464                 if (child->loadLyXFile() != Buffer::ReadSuccess) {
 465                         failedtoload_ = true;
 466                         child->setParent(0);
 467                         //close the buffer we just opened
 468                         theBufferList().release(child);
 469                         return 0;
 470                 }
 471
 472                 if (!child->errorList("Parse").empty()) {
 473                         // FIXME: Do something.
 474                 }
 475         } else {
 476                 // The file was already loaded, so, simply
 477                 // inform parent buffer about local macros.
 478                 Buffer const * parent = &buffer();
 479                 child->setParent(parent);
 480                 MacroNameSet macros;
 481                 child->listMacroNames(macros);
 482                 MacroNameSet::const_iterator cit = macros.begin();
 483                 MacroNameSet::const_iterator end = macros.end();
 484                 for (; cit != end; ++cit)
 485                         parent->usermacros.insert(*cit);
 486         }
 487
 488         // Cache the child buffer.
 489         child_buffer_ = child;
 490         return child;
 491 }
 492
 493
 494 void InsetInclude::latex(otexstream & os, OutputParams const & runparams) const
 495 {
 496         string incfile = to_utf8(params()["filename"]);
 497
 498         // Do nothing if no file name has been specified
 499         if (incfile.empty())
 500                 return;
 501
 502         FileName const included_file = includedFileName(buffer(), params());
 503
 504         // Check we're not trying to include ourselves.
 505         // FIXME RECURSIVE INCLUDE
 506         // This isn't sufficient, as the inclusion could be downstream.
 507         // But it'll have to do for now.
 508         if (isInputOrInclude(params()) &&
 509                 buffer().absFileName() == included_file.absFileName())
 510         {
 511                 Alert::error(_("Recursive input"),
 512                                bformat(_("Attempted to include file %1$s in itself! "
 513                                "Ignoring inclusion."), from_utf8(incfile)));
 514                 return;
 515         }
 516
 517         Buffer const * const masterBuffer = buffer().masterBuffer();
 518
 519         // if incfile is relative, make it relative to the master
 520         // buffer directory.
 521         if (!FileName::isAbsolute(incfile)) {
 522                 // FIXME UNICODE
 523                 incfile = to_utf8(makeRelPath(from_utf8(included_file.absFileName()),
 524                                               from_utf8(masterBuffer->filePath())));
 525         }
 526
 527         string exppath = incfile;
 528         if (!runparams.export_folder.empty()) {
 529                 exppath = makeAbsPath(exppath, runparams.export_folder).realPath();
 530                 FileName(exppath).onlyPath().createPath();
 531         }
 532
 533         // write it to a file (so far the complete file)
 534         string exportfile;
 535         string mangled;
 536         // bug 5681
 537         if (type(params()) == LISTINGS) {
 538                 exportfile = exppath;
 539                 mangled = DocFileName(included_file).mangledFileName();
 540         } else {
 541                 exportfile = changeExtension(exppath, ".tex");
 542                 mangled = DocFileName(changeExtension(included_file.absFileName(), ".tex")).
 543                         mangledFileName();
 544         }
 545
 546         if (!runparams.nice)
 547                 incfile = mangled;
 548         else if (!runparams.silent)
 549                 ; // no warning wanted
 550         else if (!isValidLaTeXFileName(incfile)) {
 551                 frontend::Alert::warning(_("Invalid filename"),
 552                         _("The following filename will cause troubles "
 553                                 "when running the exported file through LaTeX: ") +
 554                         from_utf8(incfile));
 555         } else if (!isValidDVIFileName(incfile)) {
 556                 frontend::Alert::warning(_("Problematic filename for DVI"),
 557                         _("The following filename can cause troubles "
 558                                 "when running the exported file through LaTeX "
 559                                 "and opening the resulting DVI: ") +
 560                         from_utf8(incfile), true);
 561         }
 562
 563         FileName const writefile(makeAbsPath(mangled, runparams.for_preview ?
 564                                                  buffer().temppath() : masterBuffer->temppath()));
 565
 566         LYXERR(Debug::LATEX, "incfile:" << incfile);
 567         LYXERR(Debug::LATEX, "exportfile:" << exportfile);
 568         LYXERR(Debug::LATEX, "writefile:" << writefile);
 569
 570         string const tex_format = flavor2format(runparams.flavor);
 571
 572         switch (type(params())) {
 573         case VERB:
 574         case VERBAST: {
 575                 incfile = latex_path(incfile);
 576                 // FIXME UNICODE
 577                 os << '\\' << from_ascii(params().getCmdName()) << '{'
 578                    << from_utf8(incfile) << '}';
 579                 break;
 580         }
 581         case INPUT: {
 582                 runparams.exportdata->addExternalFile(tex_format, writefile,
 583                                                       exportfile);
 584
 585                 // \input wants file with extension (default is .tex)
 586                 if (!isLyXFileName(included_file.absFileName())) {
 587                         incfile = latex_path(incfile);
 588                         // FIXME UNICODE
 589                         os << '\\' << from_ascii(params().getCmdName())
 590                            << '{' << from_utf8(incfile) << '}';
 591                 } else {
 592                         incfile = changeExtension(incfile, ".tex");
 593                         incfile = latex_path(incfile);
 594                         // FIXME UNICODE
 595                         os << '\\' << from_ascii(params().getCmdName())
 596                            << '{' << from_utf8(incfile) <<  '}';
 597                 }
 598                 break;
 599         }
 600         case LISTINGS: {
 601                 runparams.exportdata->addExternalFile(tex_format, writefile,
 602                                                       exportfile);
 603                 os << '\\' << from_ascii(params().getCmdName());
 604                 string const opt = to_utf8(params()["lstparams"]);
 605                 // opt is set in QInclude dialog and should have passed validation.
 606                 InsetListingsParams params(opt);
 607                 if (!params.params().empty())
 608                         os << "[" << from_utf8(params.params()) << "]";
 609                 os << '{'  << from_utf8(incfile) << '}';
 610                 break;
 611         }
 612         case INCLUDE: {
 613                 runparams.exportdata->addExternalFile(tex_format, writefile,
 614                                                       exportfile);
 615
 616                 // \include don't want extension and demands that the
 617                 // file really have .tex
 618                 incfile = changeExtension(incfile, string());
 619                 incfile = latex_path(incfile);
 620                 // FIXME UNICODE
 621                 os << '\\' << from_ascii(params().getCmdName()) << '{'
 622                    << from_utf8(incfile) << '}';
 623                 break;
 624         }
 625         case NONE:
 626                 break;
 627         }
 628
 629         if (runparams.inComment || runparams.dryrun)
 630                 // Don't try to load or copy the file if we're
 631                 // in a comment or doing a dryrun
 632                 return;
 633
 634         if (isInputOrInclude(params()) &&
 635                  isLyXFileName(included_file.absFileName())) {
 636                 // if it's a LyX file and we're inputting or including,
 637                 // try to load it so we can write the associated latex
 638
 639                 Buffer * tmp = loadIfNeeded();
 640                 if (!tmp) {
 641                         if (!runparams.silent) {
 642                                 docstring text = bformat(_("Could not load included "
 643                                         "file\n`%1$s'\n"
 644                                         "Please, check whether it actually exists."),
 645                                         included_file.displayName());
 646                                 throw ExceptionMessage(ErrorException, _("Error: "),
 647                                                        text);
 648                         }
 649                         return;
 650                 }
 651
 652                 if (!runparams.silent) {
 653                         if (tmp->params().baseClass() != masterBuffer->params().baseClass()) {
 654                                 // FIXME UNICODE
 655                                 docstring text = bformat(_("Included file `%1$s'\n"
 656                                         "has textclass `%2$s'\n"
 657                                         "while parent file has textclass `%3$s'."),
 658                                         included_file.displayName(),
 659                                         from_utf8(tmp->params().documentClass().name()),
 660                                         from_utf8(masterBuffer->params().documentClass().name()));
 661                                 Alert::warning(_("Different textclasses"), text, true);
 662                         }
 663
 664                         string const child_tf = tmp->params().useNonTeXFonts ? "true" : "false";
 665                         string const master_tf = masterBuffer->params().useNonTeXFonts ? "true" : "false";
 666                         if (tmp->params().useNonTeXFonts != masterBuffer->params().useNonTeXFonts) {
 667                                 docstring text = bformat(_("Included file `%1$s'\n"
 668                                         "has use-non-TeX-fonts set to `%2$s'\n"
 669                                         "while parent file has use-non-TeX-fonts set to `%3$s'."),
 670                                         included_file.displayName(),
 671                                         from_utf8(child_tf),
 672                                         from_utf8(master_tf));
 673                                 Alert::warning(_("Different use-non-TeX-fonts settings"), text, true);
 674                         }
 675
 676                         // Make sure modules used in child are all included in master
 677                         // FIXME It might be worth loading the children's modules into the master
 678                         // over in BufferParams rather than doing this check.
 679                         LayoutModuleList const masterModules = masterBuffer->params().getModules();
 680                         LayoutModuleList const childModules = tmp->params().getModules();
 681                         LayoutModuleList::const_iterator it = childModules.begin();
 682                         LayoutModuleList::const_iterator end = childModules.end();
 683                         for (; it != end; ++it) {
 684                                 string const module = *it;
 685                                 LayoutModuleList::const_iterator found =
 686                                         find(masterModules.begin(), masterModules.end(), module);
 687                                 if (found == masterModules.end()) {
 688                                         docstring text = bformat(_("Included file `%1$s'\n"
 689                                                 "uses module `%2$s'\n"
 690                                                 "which is not used in parent file."),
 691                                                 included_file.displayName(), from_utf8(module));
 692                                         Alert::warning(_("Module not found"), text);
 693                                 }
 694                         }
 695                 }
 696
 697                 tmp->markDepClean(masterBuffer->temppath());
 698
 699                 // Don't assume the child's format is latex
 700                 string const inc_format = tmp->params().bufferFormat();
 701                 FileName const tmpwritefile(changeExtension(writefile.absFileName(),
 702                         theFormats().extension(inc_format)));
 703
 704                 // FIXME: handle non existing files
 705                 // The included file might be written in a different encoding
 706                 // and language.
 707                 Encoding const * const oldEnc = runparams.encoding;
 708                 Language const * const oldLang = runparams.master_language;
 709                 // If the master uses non-TeX fonts (XeTeX, LuaTeX),
 710                 // the children must be encoded in plain utf8!
 711                 runparams.encoding = masterBuffer->params().useNonTeXFonts ?
 712                         encodings.fromLyXName("utf8-plain")
 713                         : &tmp->params().encoding();
 714                 runparams.master_language = buffer().params().language;
 715                 runparams.par_begin = 0;
 716                 runparams.par_end = tmp->paragraphs().size();
 717                 runparams.is_child = true;
 718                 if (!tmp->makeLaTeXFile(tmpwritefile, masterFileName(buffer()).
 719                                 onlyPath().absFileName(), runparams, Buffer::OnlyBody)) {
 720                         if (!runparams.silent) {
 721                                 docstring msg = bformat(_("Included file `%1$s' "
 722                                         "was not exported correctly.\n "
 723                                         "LaTeX export is probably incomplete."),
 724                                         included_file.displayName());
 725                                 ErrorList const & el = tmp->errorList("Export");
 726                                 if (!el.empty())
 727                                         msg = bformat(from_ascii("%1$s\n\n%2$s\n\n%3$s"),
 728                                                 msg, el.begin()->error,
 729                                                 el.begin()->description);
 730                                 throw ExceptionMessage(ErrorException, _("Error: "),
 731                                                        msg);
 732                         }
 733                 }
 734                 runparams.encoding = oldEnc;
 735                 runparams.master_language = oldLang;
 736                 runparams.is_child = false;
 737
 738                 // If needed, use converters to produce a latex file from the child
 739                 if (tmpwritefile != writefile) {
 740                         ErrorList el;
 741                         bool const success =
 742                                 theConverters().convert(tmp, tmpwritefile, writefile,
 743                                                         included_file,
 744                                                         inc_format, tex_format, el);
 745
 746                         if (!success && !runparams.silent) {
 747                                 docstring msg = bformat(_("Included file `%1$s' "
 748                                                 "was not exported correctly.\n "
 749                                                 "LaTeX export is probably incomplete."),
 750                                                 included_file.displayName());
 751                                 if (!el.empty())
 752                                         msg = bformat(from_ascii("%1$s\n\n%2$s\n\n%3$s"),
 753                                                         msg, el.begin()->error,
 754                                                         el.begin()->description);
 755                                 throw ExceptionMessage(ErrorException, _("Error: "),
 756                                                        msg);
 757                         }
 758                 }
 759         } else {
 760                 // In this case, it's not a LyX file, so we copy the file
 761                 // to the temp dir, so that .aux files etc. are not created
 762                 // in the original dir. Files included by this file will be
 763                 // found via either the environment variable TEXINPUTS, or
 764                 // input@path, see ../Buffer.cpp.
 765                 unsigned long const checksum_in  = included_file.checksum();
 766                 unsigned long const checksum_out = writefile.checksum();
 767
 768                 if (checksum_in != checksum_out) {
 769                         if (!included_file.copyTo(writefile)) {
 770                                 // FIXME UNICODE
 771                                 LYXERR(Debug::LATEX,
 772                                         to_utf8(bformat(_("Could not copy the file\n%1$s\n"
 773                                                                         "into the temporary directory."),
 774                                                          from_utf8(included_file.absFileName()))));
 775                                 return;
 776                         }
 777                 }
 778         }
 779 }
 780
 781
 782 docstring InsetInclude::xhtml(XHTMLStream & xs, OutputParams const & rp) const
 783 {
 784         if (rp.inComment)
 785                  return docstring();
 786
 787         // For verbatim and listings, we just include the contents of the file as-is.
 788         // In the case of listings, we wrap it in <pre>.
 789         bool const listing = isListings(params());
 790         if (listing || isVerbatim(params())) {
 791                 if (listing)
 792                         xs << html::StartTag("pre");
 793                 // FIXME: We don't know the encoding of the file, default to UTF-8.
 794                 xs << includedFileName(buffer(), params()).fileContents("UTF-8");
 795                 if (listing)
 796                         xs << html::EndTag("pre");
 797                 return docstring();
 798         }
 799
 800         // We don't (yet) know how to Input or Include non-LyX files.
 801         // (If we wanted to get really arcane, we could run some tex2html
 802         // converter on the included file. But that's just masochistic.)
 803         FileName const included_file = includedFileName(buffer(), params());
 804         if (!isLyXFileName(included_file.absFileName())) {
 805                 if (!rp.silent)
 806                         frontend::Alert::warning(_("Unsupported Inclusion"),
 807                                          bformat(_("LyX does not know how to include non-LyX files when "
 808                                                    "generating HTML output. Offending file:\n%1$s"),
 809                                                     params()["filename"]));
 810                 return docstring();
 811         }
 812
 813         // In the other cases, we will generate the HTML and include it.
 814
 815         // Check we're not trying to include ourselves.
 816         // FIXME RECURSIVE INCLUDE
 817         if (buffer().absFileName() == included_file.absFileName()) {
 818                 Alert::error(_("Recursive input"),
 819                                bformat(_("Attempted to include file %1$s in itself! "
 820                                "Ignoring inclusion."), params()["filename"]));
 821                 return docstring();
 822         }
 823
 824         Buffer const * const ibuf = loadIfNeeded();
 825         if (!ibuf)
 826                 return docstring();
 827
 828         // are we generating only some paragraphs, or all of them?
 829         bool const all_pars = !rp.dryrun ||
 830                         (rp.par_begin == 0 &&
 831                          rp.par_end == (int)buffer().text().paragraphs().size());
 832
 833         OutputParams op = rp;
 834         if (all_pars) {
 835                 op.par_begin = 0;
 836                 op.par_end = 0;
 837                 ibuf->writeLyXHTMLSource(xs.os(), op, Buffer::IncludedFile);
 838         } else
 839                 xs << XHTMLStream::ESCAPE_NONE
 840                    << "<!-- Included file: "
 841                    << from_utf8(included_file.absFileName())
 842                    << XHTMLStream::ESCAPE_NONE
 843                          << " -->";
 844         return docstring();
 845 }
 846
 847
 848 int InsetInclude::plaintext(odocstringstream & os,
 849         OutputParams const & op, size_t) const
 850 {
 851         // just write the filename if we're making a tooltip or toc entry,
 852         // or are generating this for advanced search
 853         if (op.for_tooltip || op.for_toc || op.for_search) {
 854                 os << '[' << screenLabel() << '\n'
 855                    << getParam("filename") << "\n]";
 856                 return PLAINTEXT_NEWLINE + 1; // one char on a separate line
 857         }
 858
 859         if (isVerbatim(params()) || isListings(params())) {
 860                 os << '[' << screenLabel() << '\n'
 861                    // FIXME: We don't know the encoding of the file, default to UTF-8.
 862                    << includedFileName(buffer(), params()).fileContents("UTF-8")
 863                    << "\n]";
 864                 return PLAINTEXT_NEWLINE + 1; // one char on a separate line
 865         }
 866
 867         Buffer const * const ibuf = loadIfNeeded();
 868         if (!ibuf) {
 869                 docstring const str = '[' + screenLabel() + ']';
 870                 os << str;
 871                 return str.size();
 872         }
 873         writePlaintextFile(*ibuf, os, op);
 874         return 0;
 875 }
 876
 877
 878 int InsetInclude::docbook(odocstream & os, OutputParams const & runparams) const
 879 {
 880         string incfile = to_utf8(params()["filename"]);
 881
 882         // Do nothing if no file name has been specified
 883         if (incfile.empty())
 884                 return 0;
 885
 886         string const included_file = includedFileName(buffer(), params()).absFileName();
 887
 888         // Check we're not trying to include ourselves.
 889         // FIXME RECURSIVE INCLUDE
 890         // This isn't sufficient, as the inclusion could be downstream.
 891         // But it'll have to do for now.
 892         if (buffer().absFileName() == included_file) {
 893                 Alert::error(_("Recursive input"),
 894                                bformat(_("Attempted to include file %1$s in itself! "
 895                                "Ignoring inclusion."), from_utf8(incfile)));
 896                 return 0;
 897         }
 898
 899         string exppath = incfile;
 900         if (!runparams.export_folder.empty()) {
 901                 exppath = makeAbsPath(exppath, runparams.export_folder).realPath();
 902                 FileName(exppath).onlyPath().createPath();
 903         }
 904
 905         // write it to a file (so far the complete file)
 906         string const exportfile = changeExtension(exppath, ".sgml");
 907         DocFileName writefile(changeExtension(included_file, ".sgml"));
 908
 909         Buffer * tmp = loadIfNeeded();
 910         if (tmp) {
 911                 string const mangled = writefile.mangledFileName();
 912                 writefile = makeAbsPath(mangled,
 913                                         buffer().masterBuffer()->temppath());
 914                 if (!runparams.nice)
 915                         incfile = mangled;
 916
 917                 LYXERR(Debug::LATEX, "incfile:" << incfile);
 918                 LYXERR(Debug::LATEX, "exportfile:" << exportfile);
 919                 LYXERR(Debug::LATEX, "writefile:" << writefile);
 920
 921                 tmp->makeDocBookFile(writefile, runparams, Buffer::OnlyBody);
 922         }
 923
 924         runparams.exportdata->addExternalFile("docbook", writefile,
 925                                               exportfile);
 926         runparams.exportdata->addExternalFile("docbook-xml", writefile,
 927                                               exportfile);
 928
 929         if (isVerbatim(params()) || isListings(params())) {
 930                 os << "<inlinegraphic fileref=\""
 931                    << '&' << include_label << ';'
 932                    << "\" format=\"linespecific\">";
 933         } else
 934                 os << '&' << include_label << ';';
 935
 936         return 0;
 937 }
 938
 939
 940 void InsetInclude::validate(LaTeXFeatures & features) const
 941 {
 942         LATTEST(&buffer() == &features.buffer());
 943
 944         string incfile = to_utf8(params()["filename"]);
 945         string const included_file =
 946                 includedFileName(buffer(), params()).absFileName();
 947
 948         string writefile;
 949         if (isLyXFileName(included_file))
 950                 writefile = changeExtension(included_file, ".sgml");
 951         else
 952                 writefile = included_file;
 953
 954         if (!features.runparams().nice && !isVerbatim(params()) && !isListings(params())) {
 955                 incfile = DocFileName(writefile).mangledFileName();
 956                 writefile = makeAbsPath(incfile,
 957                                         buffer().masterBuffer()->temppath()).absFileName();
 958         }
 959
 960         features.includeFile(include_label, writefile);
 961
 962         features.useInsetLayout(getLayout());
 963         if (isVerbatim(params()))
 964                 features.require("verbatim");
 965         else if (isListings(params()))
 966                 features.require("listings");
 967
 968         // Here we must do the fun stuff...
 969         // Load the file in the include if it needs
 970         // to be loaded:
 971         Buffer * const tmp = loadIfNeeded();
 972         if (tmp) {
 973                 // the file is loaded
 974                 // make sure the buffer isn't us
 975                 // FIXME RECURSIVE INCLUDES
 976                 // This is not sufficient, as recursive includes could be
 977                 // more than a file away. But it will do for now.
 978                 if (tmp && tmp != &buffer()) {
 979                         // We must temporarily change features.buffer,
 980                         // otherwise it would always be the master buffer,
 981                         // and nested includes would not work.
 982                         features.setBuffer(*tmp);
 983                         // Maybe this is already a child
 984                         bool const is_child =
 985                                 features.runparams().is_child;
 986                         features.runparams().is_child = true;
 987                         tmp->validate(features);
 988                         features.runparams().is_child = is_child;
 989                         features.setBuffer(buffer());
 990                 }
 991         }
 992 }
 993
 994
 995 void InsetInclude::collectBibKeys(InsetIterator const & /*di*/) const
 996 {
 997         Buffer * child = loadIfNeeded();
 998         if (!child)
 999                 return;
1000         // FIXME RECURSIVE INCLUDE
1001         // This isn't sufficient, as the inclusion could be downstream.
1002         // But it'll have to do for now.
1003         if (child == &buffer())
1004                 return;
1005         child->collectBibKeys();
1006 }
1007
1008
1009 void InsetInclude::metrics(MetricsInfo & mi, Dimension & dim) const
1010 {
1011         LBUFERR(mi.base.bv);
1012
1013         bool use_preview = false;
1014         if (RenderPreview::previewText()) {
1015                 graphics::PreviewImage const * pimage =
1016                         preview_->getPreviewImage(mi.base.bv->buffer());
1017                 use_preview = pimage && pimage->image();
1018         }
1019
1020         if (use_preview) {
1021                 preview_->metrics(mi, dim);
1022         } else {
1023                 if (!set_label_) {
1024                         set_label_ = true;
1025                         button_.update(screenLabel(), true, false);
1026                 }
1027                 button_.metrics(mi, dim);
1028         }
1029
1030         Box b(0, dim.wid, -dim.asc, dim.des);
1031         button_.setBox(b);
1032 }
1033
1034
1035 void InsetInclude::draw(PainterInfo & pi, int x, int y) const
1036 {
1037         LBUFERR(pi.base.bv);
1038
1039         bool use_preview = false;
1040         if (RenderPreview::previewText()) {
1041                 graphics::PreviewImage const * pimage =
1042                         preview_->getPreviewImage(pi.base.bv->buffer());
1043                 use_preview = pimage && pimage->image();
1044         }
1045
1046         if (use_preview)
1047                 preview_->draw(pi, x, y);
1048         else
1049                 button_.draw(pi, x, y);
1050 }
1051
1052
1053 void InsetInclude::write(ostream & os) const
1054 {
1055         params().Write(os, &buffer());
1056 }
1057
1058
1059 string InsetInclude::contextMenuName() const
1060 {
1061         return "context-include";
1062 }
1063
1064
1065 Inset::DisplayType InsetInclude::display() const
1066 {
1067         return type(params()) == INPUT ? Inline : AlignCenter;
1068 }
1069
1070
1071 docstring InsetInclude::layoutName() const
1072 {
1073         if (isListings(params()))
1074                 return from_ascii("IncludeListings");
1075         return InsetCommand::layoutName();
1076 }
1077
1078
1079 //
1080 // preview stuff
1081 //
1082
1083 void InsetInclude::fileChanged() const
1084 {
1085         Buffer const * const buffer = updateFrontend();
1086         if (!buffer)
1087                 return;
1088
1089         preview_->removePreview(*buffer);
1090         add_preview(*preview_, *this, *buffer);
1091         preview_->startLoading(*buffer);
1092 }
1093
1094
1095 namespace {
1096
1097 bool preview_wanted(InsetCommandParams const & params, Buffer const & buffer)
1098 {
1099         FileName const included_file = includedFileName(buffer, params);
1100
1101         return type(params) == INPUT && params.preview() &&
1102                 included_file.isReadableFile();
1103 }
1104
1105
1106 docstring latexString(InsetInclude const & inset)
1107 {
1108         odocstringstream ods;
1109         otexstream os(ods);
1110         // We don't need to set runparams.encoding since this will be done
1111         // by latex() anyway.
1112         OutputParams runparams(0);
1113         runparams.flavor = OutputParams::LATEX;
1114         runparams.for_preview = true;
1115         inset.latex(os, runparams);
1116
1117         return ods.str();
1118 }
1119
1120
1121 void add_preview(RenderMonitoredPreview & renderer, InsetInclude const & inset,
1122                  Buffer const & buffer)
1123 {
1124         InsetCommandParams const & params = inset.params();
1125         if (RenderPreview::previewText() && preview_wanted(params, buffer)) {
1126                 renderer.setAbsFile(includedFileName(buffer, params));
1127                 docstring const snippet = latexString(inset);
1128                 renderer.addPreview(snippet, buffer);
1129         }
1130 }
1131
1132 } // namespace anon
1133
1134
1135 void InsetInclude::addPreview(DocIterator const & /*inset_pos*/,
1136         graphics::PreviewLoader & ploader) const
1137 {
1138         Buffer const & buffer = ploader.buffer();
1139         if (!preview_wanted(params(), buffer))
1140                 return;
1141         preview_->setAbsFile(includedFileName(buffer, params()));
1142         docstring const snippet = latexString(*this);
1143         preview_->addPreview(snippet, ploader);
1144 }
1145
1146
1147 void InsetInclude::addToToc(DocIterator const & cpit, bool output_active,
1148                             UpdateType utype, TocBackend & backend) const
1149 {
1150         if (isListings(params())) {
1151                 if (label_)
1152                         label_->addToToc(cpit, output_active, utype, backend);
1153                 TocBuilder & b = backend.builder("listing");
1154                 b.pushItem(cpit, screenLabel(), output_active);
1155                 InsetListingsParams p(to_utf8(params()["lstparams"]));
1156                 b.argumentItem(from_utf8(p.getParamValue("caption")));
1157                 b.pop();
1158         } else {
1159                 Buffer const * const childbuffer = getChildBuffer();
1160
1161                 TocBuilder & b = backend.builder("child");
1162                 docstring str = childbuffer ? childbuffer->fileName().displayName()
1163                         : from_ascii("?");
1164                 b.pushItem(cpit, str, output_active);
1165                 b.pop();
1166
1167                 if (!childbuffer)
1168                         return;
1169
1170                 // Include Tocs from children
1171                 childbuffer->inset().addToToc(DocIterator(), output_active, utype,
1172                                               backend);
1173                 //Copy missing outliner names (though the user has been warned against
1174                 //having different document class and module selection between master
1175                 //and child).
1176                 for (pair<string, docstring> const & name
1177                              : childbuffer->params().documentClass().outlinerNames())
1178                         backend.addName(name.first, translateIfPossible(name.second));
1179         }
1180 }
1181
1182
1183 void InsetInclude::updateCommand()
1184 {
1185         if (!label_)
1186                 return;
1187
1188         docstring old_label = label_->getParam("name");
1189         label_->updateLabel(old_label);
1190         // the label might have been adapted (duplicate)
1191         docstring new_label = label_->getParam("name");
1192         if (old_label == new_label)
1193                 return;
1194
1195         // update listings parameters...
1196         InsetCommandParams p(INCLUDE_CODE);
1197         p = params();
1198         InsetListingsParams par(to_utf8(params()["lstparams"]));
1199         par.addParam("label", "{" + to_utf8(new_label) + "}", true);
1200         p["lstparams"] = from_utf8(par.params());
1201         setParams(p);
1202 }
1203
1204
1205 void InsetInclude::updateBuffer(ParIterator const & it, UpdateType utype)
1206 {
1207         button_.update(screenLabel(), true, false);
1208
1209         Buffer const * const childbuffer = getChildBuffer();
1210         if (childbuffer) {
1211                 childbuffer->updateBuffer(Buffer::UpdateChildOnly, utype);
1212                 return;
1213         }
1214         if (!isListings(params()))
1215                 return;
1216
1217         if (label_)
1218                 label_->updateBuffer(it, utype);
1219
1220         InsetListingsParams const par(to_utf8(params()["lstparams"]));
1221         if (par.getParamValue("caption").empty()) {
1222                 listings_label_ = buffer().B_("Program Listing");
1223                 return;
1224         }
1225         Buffer const & master = *buffer().masterBuffer();
1226         Counters & counters = master.params().documentClass().counters();
1227         docstring const cnt = from_ascii("listing");
1228         listings_label_ = master.B_("Program Listing");
1229         if (counters.hasCounter(cnt)) {
1230                 counters.step(cnt, utype);
1231                 listings_label_ += " " + convert<docstring>(counters.value(cnt));
1232         }
1233 }
1234
1235
1236 } // namespace lyx