src/bufferlist.C

   1 /**
   2  * \file bufferlist.C
   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  *
   8  * Full author contact details are available in file CREDITS
   9  */
  10
  11 #include <config.h>
  12
  13 #include "bufferlist.h"
  14 #include "lyx_main.h"
  15 #include "lastfiles.h"
  16 #include "debug.h"
  17 #include "lyxrc.h"
  18 #include "lyxtext.h"
  19 #include "lyx_cb.h"
  20 #include "bufferview_funcs.h"
  21 #include "BufferView.h"
  22 #include "gettext.h"
  23 #include "frontends/LyXView.h"
  24 #include "vc-backend.h"
  25 #include "TextCache.h"
  26 #include "lyxlex.h"
  27
  28 #include "frontends/Alert.h"
  29
  30 #include "support/FileInfo.h"
  31 #include "support/filetools.h"
  32 #include "support/lyxmanip.h"
  33 #include "support/lyxfunctional.h"
  34 #include "support/LAssert.h"
  35
  36 #include <boost/bind.hpp>
  37
  38 #include <cassert>
  39 #include <algorithm>
  40 #include <functional>
  41
  42
  43 using std::vector;
  44 using std::find;
  45 using std::endl;
  46 using std::find_if;
  47 using std::for_each;
  48 using std::mem_fun;
  49
  50 extern BufferView * current_view;
  51
  52
  53 BufferList::BufferList()
  54 {}
  55
  56
  57 bool BufferList::empty() const
  58 {
  59         return bstore.empty();
  60 }
  61
  62
  63 bool BufferList::quitWriteBuffer(Buffer * buf)
  64 {
  65         string file;
  66         if (buf->isUnnamed())
  67                 file = OnlyFilename(buf->fileName());
  68         else
  69                 file = MakeDisplayPath(buf->fileName(), 30);
  70
  71         string text = bformat(_("The document %1$s has unsaved changes.\n\n"
  72                 "Do you want to save the document?"), file);
  73         int const ret = Alert::prompt(_("Save changed document?"),
  74                 text, 0, 2, _("&Save Changes"), _("&Discard Changes"), _("&Cancel"));
  75
  76         if (ret == 0) {
  77                 // FIXME: WriteAs can be asynch !
  78                 // but not right now...maybe we should remove that
  79
  80                 bool succeeded;
  81
  82                 if (buf->isUnnamed())
  83                         succeeded = WriteAs(current_view, buf);
  84                 else
  85                         succeeded = MenuWrite(current_view, buf);
  86
  87                 if (!succeeded)
  88                         return false;
  89         } else if (ret == 1) {
  90                 // if we crash after this we could
  91                 // have no autosave file but I guess
  92                 // this is really inprobable (Jug)
  93                 if (buf->isUnnamed())
  94                         removeAutosaveFile(buf->fileName());
  95
  96         } else {
  97                 return false;
  98         }
  99
 100         return true;
 101 }
 102
 103
 104 bool BufferList::quitWriteAll()
 105 {
 106         BufferStorage::iterator it = bstore.begin();
 107         BufferStorage::iterator end = bstore.end();
 108         for (; it != end; ++it) {
 109                 if ((*it)->isClean())
 110                         continue;
 111
 112                 if (!quitWriteBuffer(*it))
 113                         return false;
 114         }
 115
 116         return true;
 117 }
 118
 119
 120 void BufferList::release(Buffer * buf)
 121 {
 122         lyx::Assert(buf);
 123         BufferStorage::iterator it = find(bstore.begin(), bstore.end(), buf);
 124         if (it != bstore.end()) {
 125                 // Make sure that we don't store a LyXText in
 126                 // the textcache that points to the buffer
 127                 // we just deleted.
 128                 Buffer * tmp = (*it);
 129                 bstore.erase(it);
 130                 textcache.removeAllWithBuffer(tmp);
 131                 delete tmp;
 132         }
 133 }
 134
 135
 136 Buffer * BufferList::newBuffer(string const & s, bool ronly)
 137 {
 138         Buffer * tmpbuf = new Buffer(s, ronly);
 139         tmpbuf->params.useClassDefaults();
 140         lyxerr[Debug::INFO] << "Assigning to buffer "
 141                             << bstore.size() << endl;
 142         bstore.push_back(tmpbuf);
 143         return tmpbuf;
 144 }
 145
 146
 147 void BufferList::closeAll()
 148 {
 149         // Since we are closing we can just as well delete all
 150         // in the textcache this will also speed the closing/quiting up a bit.
 151         textcache.clear();
 152
 153         while (!bstore.empty()) {
 154                 close(bstore.front(), false);
 155         }
 156 }
 157
 158
 159 bool BufferList::close(Buffer * buf, bool ask)
 160 {
 161         lyx::Assert(buf);
 162
 163         // FIXME: is the quitting check still necessary ?
 164         if (!ask || buf->isClean() || quitting || buf->paragraphs.empty()) {
 165                 release(buf);
 166                 return true;
 167         }
 168
 169         string fname;
 170         if (buf->isUnnamed())
 171                 fname = OnlyFilename(buf->fileName());
 172         else
 173                 fname = MakeDisplayPath(buf->fileName(), 30);
 174
 175         string text = bformat(_("The document %1$s has unsaved changes.\n\n"
 176                 "Do you want to save the document?"), fname);
 177         int const ret = Alert::prompt(_("Save changed document?"),
 178                 text, 0, 2, _("&Save Changes"), _("&Discard Changes"), _("&Cancel"));
 179
 180         if (ret == 0) {
 181                 if (buf->isUnnamed()) {
 182                         if (!WriteAs(current_view, buf))
 183                                 return false;
 184                 } else if (buf->save()) {
 185                         lastfiles->newFile(buf->fileName());
 186                 } else {
 187                         return false;
 188                 }
 189         } else if (ret == 2) {
 190                 return false;
 191         }
 192
 193         if (buf->isUnnamed()) {
 194                 removeAutosaveFile(buf->fileName());
 195         }
 196
 197         release(buf);
 198         return true;
 199 }
 200
 201
 202 vector<string> const BufferList::getFileNames() const
 203 {
 204         vector<string> nvec;
 205         std::copy(bstore.begin(), bstore.end(),
 206                   lyx::back_inserter_fun(nvec, &Buffer::fileName));
 207         return nvec;
 208 }
 209
 210
 211 Buffer * BufferList::first()
 212 {
 213         if (bstore.empty())
 214                 return 0;
 215         return bstore.front();
 216 }
 217
 218
 219 Buffer * BufferList::getBuffer(unsigned int choice)
 220 {
 221         if (choice >= bstore.size())
 222                 return 0;
 223         return bstore[choice];
 224 }
 225
 226
 227 void BufferList::updateIncludedTeXfiles(string const & mastertmpdir)
 228 {
 229         BufferStorage::iterator it = bstore.begin();
 230         BufferStorage::iterator end = bstore.end();
 231         for (; it != end; ++it) {
 232                 if (!(*it)->isDepClean(mastertmpdir)) {
 233                         string writefile = mastertmpdir;
 234                         writefile += '/';
 235                         writefile += (*it)->getLatexName();
 236                         (*it)->makeLaTeXFile(writefile, mastertmpdir,
 237                                              false, true);
 238                         (*it)->markDepClean(mastertmpdir);
 239                 }
 240         }
 241 }
 242
 243
 244 void BufferList::emergencyWriteAll()
 245 {
 246         for_each(bstore.begin(), bstore.end(),
 247                  boost::bind(&BufferList::emergencyWrite, this, _1));
 248 }
 249
 250
 251 void BufferList::emergencyWrite(Buffer * buf)
 252 {
 253         // assert(buf) // this is not good since C assert takes an int
 254                        // and a pointer is a long (JMarc)
 255         assert(buf != 0); // use c assert to avoid a loop
 256
 257
 258         // No need to save if the buffer has not changed.
 259         if (buf->isClean())
 260                 return;
 261
 262         string const doc = buf->isUnnamed()
 263                 ? OnlyFilename(buf->fileName()) : buf->fileName();
 264
 265         lyxerr << bformat(_("LyX: Attempting to save document %1$s"), doc) << endl;
 266
 267         // We try to save three places:
 268         // 1) Same place as document. Unless it is an unnamed doc.
 269         if (!buf->isUnnamed()) {
 270                 string s = buf->fileName();
 271                 s += ".emergency";
 272                 lyxerr << "  " << s << endl;
 273                 if (buf->writeFile(s)) {
 274                         buf->markClean();
 275                         lyxerr << _("  Save seems successful. Phew.") << endl;
 276                         return;
 277                 } else {
 278                         lyxerr << _("  Save failed! Trying...") << endl;
 279                 }
 280         }
 281
 282         // 2) In HOME directory.
 283         string s = AddName(GetEnvPath("HOME"), buf->fileName());
 284         s += ".emergency";
 285         lyxerr << ' ' << s << endl;
 286         if (buf->writeFile(s)) {
 287                 buf->markClean();
 288                 lyxerr << _("  Save seems successful. Phew.") << endl;
 289                 return;
 290         }
 291
 292         lyxerr << _("  Save failed! Trying...") << endl;
 293
 294         // 3) In "/tmp" directory.
 295         // MakeAbsPath to prepend the current
 296         // drive letter on OS/2
 297         s = AddName(MakeAbsPath("/tmp/"), buf->fileName());
 298         s += ".emergency";
 299         lyxerr << ' ' << s << endl;
 300         if (buf->writeFile(s)) {
 301                 buf->markClean();
 302                 lyxerr << _("  Save seems successful. Phew.") << endl;
 303                 return;
 304         }
 305         lyxerr << _("  Save failed! Bummer. Document is lost.") << endl;
 306 }
 307
 308
 309
 310 Buffer * BufferList::readFile(string const & s, bool ronly)
 311 {
 312         string ts(s);
 313         string e = OnlyPath(s);
 314         string a = e;
 315         // File information about normal file
 316         FileInfo fileInfo2(s);
 317
 318         if (!fileInfo2.exist()) {
 319                 string const file = MakeDisplayPath(s, 50);
 320                 string text = bformat(_("The specified document\n%1$s"
 321                         "\ncould not be read."),        file);
 322                 Alert::error(_("Could not read document"), text);
 323                 return 0;
 324         }
 325
 326         Buffer * b = newBuffer(s, ronly);
 327
 328         // Check if emergency save file exists and is newer.
 329         e += OnlyFilename(s) + ".emergency";
 330         FileInfo fileInfoE(e);
 331
 332         bool use_emergency = false;
 333
 334         if (fileInfoE.exist() && fileInfo2.exist()) {
 335                 if (fileInfoE.getModificationTime()
 336                     > fileInfo2.getModificationTime()) {
 337                         string const file = MakeDisplayPath(s, 20);
 338                         string text = bformat(_("An emergency save of the document %1$s exists.\n"
 339                                 "\nRecover emergency save?"), file);
 340                         int const ret = Alert::prompt(_("Load emergency save?"),
 341                                 text, 0, 1, _("&Recover"), _("&Load Original"));
 342
 343                         if (ret == 0) {
 344                                 ts = e;
 345                                 // the file is not saved if we load the
 346                                 // emergency file.
 347                                 b->markDirty();
 348                                 use_emergency = true;
 349                         }
 350                 }
 351         }
 352
 353         if (!use_emergency) {
 354                 // Now check if autosave file is newer.
 355                 a += '#';
 356                 a += OnlyFilename(s);
 357                 a += '#';
 358                 FileInfo fileInfoA(a);
 359                 if (fileInfoA.exist() && fileInfo2.exist()) {
 360                         if (fileInfoA.getModificationTime()
 361                             > fileInfo2.getModificationTime()) {
 362                                 string const file = MakeDisplayPath(s, 20);
 363                                 string text = bformat(_("The backup of the document %1$s is newer.\n\n"
 364                                         "Load the backup instead?"), file);
 365                                 int const ret = Alert::prompt(_("Load backup?"),
 366                                         text, 0, 1, _("&Load backup"), _("Load &original"));
 367
 368                                 if (ret == 0) {
 369                                         ts = a;
 370                                         // the file is not saved if we load the
 371                                         // autosave file.
 372                                         b->markDirty();
 373                                 } else {
 374                                         // Here, we should delete the autosave
 375                                         lyx::unlink(a);
 376                                 }
 377                         }
 378                 }
 379         }
 380         // not sure if this is the correct place to begin LyXLex
 381         LyXLex lex(0, 0);
 382         lex.setFile(ts);
 383         if (b->readFile(lex, ts))
 384                 return b;
 385         else {
 386                 release(b);
 387                 return 0;
 388         }
 389 }
 390
 391
 392 bool BufferList::exists(string const & s) const
 393 {
 394         return find_if(bstore.begin(), bstore.end(),
 395                        lyx::compare_memfun(&Buffer::fileName, s))
 396                 != bstore.end();
 397 }
 398
 399
 400 bool BufferList::isLoaded(Buffer const * b) const
 401 {
 402         lyx::Assert(b);
 403
 404         BufferStorage::const_iterator cit =
 405                 find(bstore.begin(), bstore.end(), b);
 406         return cit != bstore.end();
 407 }
 408
 409
 410 Buffer * BufferList::getBuffer(string const & s)
 411 {
 412         BufferStorage::iterator it =
 413                 find_if(bstore.begin(), bstore.end(),
 414                         lyx::compare_memfun(&Buffer::fileName, s));
 415         return it != bstore.end() ? (*it) : 0;
 416 }
 417
 418
 419 Buffer * BufferList::newFile(string const & name, string tname, bool isNamed)
 420 {
 421         // get a free buffer
 422         Buffer * b = newBuffer(name);
 423
 424         // use defaults.lyx as a default template if it exists.
 425         if (tname.empty()) {
 426                 tname = LibFileSearch("templates", "defaults.lyx");
 427         }
 428         if (!tname.empty()) {
 429                 bool templateok = false;
 430                 LyXLex lex(0, 0);
 431                 lex.setFile(tname);
 432                 if (lex.isOK()) {
 433                         if (b->readFile(lex, tname)) {
 434                                 templateok = true;
 435                         }
 436                 }
 437                 if (!templateok) {
 438                         string const file = MakeDisplayPath(tname, 50);
 439                         string text  = bformat(_("The specified document template\n%1$s\n"
 440                                 "could not be read."), file);
 441                         Alert::error(_("Could not read template"), text);
 442                         // no template, start with empty buffer
 443                         b->paragraphs.push_back(new Paragraph);
 444                         b->paragraphs.begin()->layout(b->params.getLyXTextClass().defaultLayout());
 445                 }
 446         } else {  // start with empty buffer
 447                 b->paragraphs.push_back(new Paragraph);
 448                 b->paragraphs.begin()->layout(b->params.getLyXTextClass().defaultLayout());
 449         }
 450
 451         if (!isNamed) {
 452                 b->setUnnamed();
 453                 b->setFileName(name);
 454         }
 455
 456         b->setReadonly(false);
 457         b->updateDocLang(b->params.language);
 458
 459         return b;
 460 }
 461
 462
 463 Buffer * BufferList::loadLyXFile(string const & filename, bool tolastfiles)
 464 {
 465         // get absolute path of file and add ".lyx" to the filename if
 466         // necessary
 467         string s = FileSearch(string(), filename, "lyx");
 468         if (s.empty()) {
 469                 s = filename;
 470         }
 471
 472         // file already open?
 473         if (exists(s)) {
 474                 string const file = MakeDisplayPath(s, 20);
 475                 string text = bformat(_("The document %1$s is already loaded.\n\n"
 476                         "Do you want to revert to the saved version?"), file);
 477                 int const ret = Alert::prompt(_("Revert to saved document?"),
 478                         text, 0, 1,  _("&Revert"), _("&Switch to document"));
 479
 480                 if (ret == 0) {
 481                         // FIXME: should be LFUN_REVERT
 482                         if (!close(getBuffer(s), false)) {
 483                                 return 0;
 484                         }
 485                         // Fall through to new load. (Asger)
 486                 } else {
 487                         // Here, we pretend that we just loaded the
 488                         // open document
 489                         return getBuffer(s);
 490                 }
 491         }
 492
 493         Buffer * b = 0;
 494         bool ro = false;
 495         switch (IsFileWriteable(s)) {
 496         case 0:
 497                 ro = true;
 498                 // Fall through
 499         case 1:
 500                 b = readFile(s, ro);
 501                 if (b) {
 502                         b->lyxvc.file_found_hook(s);
 503                 }
 504                 break; //fine- it's r/w
 505         case -1: {
 506                 string const file = MakeDisplayPath(s, 20);
 507                 // Here we probably should run
 508                 if (LyXVC::file_not_found_hook(s)) {
 509                         string text = bformat(_("Do you want to retrieve the document"
 510                                 " %1$s from version control?"), file);
 511                         int const ret = Alert::prompt(_("Retrieve from version control?"),
 512                                 text, 0, 1, _("&Retrieve"), _("&Cancel"));
 513
 514                         if (ret == 0) {
 515                                 // How can we know _how_ to do the checkout?
 516                                 // With the current VC support it has to be,
 517                                 // a RCS file since CVS do not have special ,v files.
 518                                 RCS::retrieve(s);
 519                                 return loadLyXFile(filename, tolastfiles);
 520                         }
 521                 }
 522
 523                 string text = bformat(_("The document %1$s does not yet exist.\n\n"
 524                         "Do you want to create a new document?"), file);
 525                 int const ret = Alert::prompt(_("Create new document?"),
 526                         text, 0, 1, _("&Create"), _("Cancel"));
 527
 528                 if (ret == 0)
 529                         b = newFile(s, string(), true);
 530
 531                 break;
 532                 }
 533         }
 534
 535         if (b && tolastfiles)
 536                 lastfiles->newFile(b->fileName());
 537
 538         return b;
 539 }
 540
 541
 542 void BufferList::setCurrentAuthor(string const & name, string const & email)
 543 {
 544         BufferStorage::iterator it = bstore.begin();
 545         BufferStorage::iterator end = bstore.end();
 546         for (; it != end; ++it) {
 547                 (*it)->authors().record(0, Author(name, email));
 548         }
 549 }