src/graphics/GraphicsLoader.cpp

   1 /**
   2  * \file GraphicsLoader.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Angus Leeming
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "GraphicsLoader.h"
  14
  15 #include "GraphicsCacheItem.h"
  16 #include "GraphicsImage.h"
  17 #include "GraphicsParams.h"
  18 #include "GraphicsCache.h"
  19
  20 #include "support/debug.h"
  21 #include "support/lassert.h"
  22 #include "support/Timeout.h"
  23
  24 #include "support/bind.h"
  25
  26 #include <queue>
  27 #include <memory>
  28 #include <set>
  29
  30 using namespace std;
  31 using namespace lyx::support;
  32
  33 namespace lyx {
  34
  35 namespace graphics {
  36
  37
  38 /////////////////////////////////////////////////////////////////////
  39 //
  40 // LoaderQueue
  41 //
  42 /////////////////////////////////////////////////////////////////////
  43
  44 class LoaderQueue {
  45 public:
  46         /// Use this to request that the item is loaded.
  47         void touch(Cache::ItemPtr const & item);
  48         /// Query whether the clock is ticking.
  49         bool running() const;
  50         ///get the and only instance of the class
  51         static LoaderQueue & get();
  52 private:
  53         /// This class is a singleton class... use LoaderQueue::get() instead
  54         LoaderQueue();
  55         /// The in-progress loading queue (elements are unique here).
  56         list<Cache::ItemPtr> cache_queue_;
  57         /// Used to make the insertion of new elements faster.
  58         set<Cache::ItemPtr> cache_set_;
  59         /// Newly touched elements go here. loadNext moves them to cache_queue_
  60         queue<Cache::ItemPtr> bucket_;
  61         ///
  62         Timeout timer;
  63         ///
  64         bool running_;
  65
  66         /** This is the 'threaded' method, that does the loading in the
  67          *  background.
  68          */
  69         void loadNext();
  70         ///
  71         void startLoader();
  72         ///
  73         void stopLoader();
  74 };
  75
  76
  77
  78 //static int const s_numimages_ = 5;
  79 static int const s_numimages_ = 10;
  80 static int const s_millisecs_ = 500;
  81
  82
  83 LoaderQueue & LoaderQueue::get()
  84 {
  85         static LoaderQueue singleton;
  86         return singleton;
  87 }
  88
  89
  90 void LoaderQueue::loadNext()
  91 {
  92         LYXERR(Debug::GRAPHICS, "LoaderQueue: "
  93                 << cache_queue_.size() << " items in the queue");
  94         int counter = s_numimages_;
  95         while (!cache_queue_.empty() && counter--) {
  96                 Cache::ItemPtr ptr = cache_queue_.front();
  97                 cache_set_.erase(ptr);
  98                 cache_queue_.pop_front();
  99                 if (ptr->status() == WaitingToLoad)
 100                         ptr->startLoading();
 101         }
 102         if (!cache_queue_.empty())
 103                 startLoader();
 104         else
 105                 stopLoader();
 106 }
 107
 108
 109 LoaderQueue::LoaderQueue() : timer(s_millisecs_, Timeout::ONETIME),
 110                              running_(false)
 111 {
 112         // Disconnected when this is destroyed
 113         timer.timeout.connect([this](){ loadNext(); });
 114 }
 115
 116
 117 void LoaderQueue::startLoader()
 118 {
 119         LYXERR(Debug::GRAPHICS, "LoaderQueue: waking up");
 120         running_ = true;
 121         timer.setTimeout(s_millisecs_);
 122         timer.start();
 123 }
 124
 125
 126 void LoaderQueue::stopLoader()
 127 {
 128         timer.stop();
 129         running_ = false ;
 130         LYXERR(Debug::GRAPHICS, "LoaderQueue: I'm going to sleep");
 131 }
 132
 133
 134 bool LoaderQueue::running() const
 135 {
 136         return running_ ;
 137 }
 138
 139
 140 void LoaderQueue::touch(Cache::ItemPtr const & item)
 141 {
 142         if (! cache_set_.insert(item).second) {
 143                 list<Cache::ItemPtr>::iterator
 144                         it = cache_queue_.begin();
 145                 list<Cache::ItemPtr>::iterator
 146                         end = cache_queue_.end();
 147
 148                 it = find(it, end, item);
 149                 if (it != end)
 150                         cache_queue_.erase(it);
 151         }
 152         cache_queue_.push_front(item);
 153         if (!running_)
 154                 startLoader();
 155 }
 156
 157
 158
 159 /////////////////////////////////////////////////////////////////////
 160 //
 161 // GraphicsLoader
 162 //
 163 /////////////////////////////////////////////////////////////////////
 164
 165 typedef std::shared_ptr<Image> ImagePtr;
 166
 167 class Loader::Impl {
 168         friend class Loader;
 169 public:
 170         ///
 171         Impl(FileName const & doc_file);
 172         ///
 173         ~Impl();
 174         ///
 175         void resetFile(FileName const &);
 176         ///
 177         void resetParams(Params const &);
 178         ///
 179         void createPixmap();
 180         ///
 181         void startLoading();
 182         ///
 183         Params const & params() const { return params_; }
 184
 185         ///
 186         FileName doc_file_;
 187         /// The loading status of the image.
 188         ImageStatus status_;
 189         /** Must store a copy of the cached item to ensure that it is not
 190          *  erased unexpectedly by the cache itself.
 191          */
 192         Cache::ItemPtr cached_item_;
 193         /// We modify a local copy of the image once it is loaded.
 194         ImagePtr image_;
 195         /// This signal is emitted when the image loading status changes.
 196         signals2::signal<void()> signal_;
 197         /// The connection of the signal statusChanged
 198         signals2::scoped_connection connection_;
 199
 200         double displayPixelRatio() const
 201         {
 202                 return params_.pixel_ratio;
 203         }
 204         void setDisplayPixelRatio(double scale)
 205         {
 206                 params_.pixel_ratio = scale;
 207         }
 208
 209 private:
 210         ///
 211         void statusChanged();
 212         ///
 213         void checkedLoading();
 214
 215         ///
 216         Params params_;
 217 };
 218
 219
 220 Loader::Loader(FileName const & doc_file)
 221         : pimpl_(new Impl(doc_file))
 222 {}
 223
 224
 225 Loader::Loader(FileName const & doc_file, FileName const & file, bool display)
 226         : pimpl_(new Impl(doc_file))
 227 {
 228         reset(file, display);
 229 }
 230
 231
 232 Loader::Loader(FileName const & doc_file, FileName const & file, Params const & params)
 233         : pimpl_(new Impl(doc_file))
 234 {
 235         reset(file, params);
 236 }
 237
 238
 239 Loader::Loader(FileName const & doc_file, Loader const & other)
 240         : pimpl_(new Impl(doc_file))
 241 {
 242         Params const & params = other.pimpl_->params();
 243         reset(params.filename, params);
 244 }
 245
 246
 247 Loader::Loader(Loader const & other)
 248         : pimpl_(new Impl(other.pimpl_->doc_file_))
 249 {
 250         Params const & params = other.pimpl_->params();
 251         reset(params.filename, params);
 252 }
 253
 254
 255 Loader::~Loader()
 256 {
 257         delete pimpl_;
 258 }
 259
 260
 261 Loader & Loader::operator=(Loader const & other)
 262 {
 263   LASSERT(false, /**/);
 264         if (this != &other) {
 265                 delete pimpl_;
 266                 pimpl_ = new Impl(other.pimpl_->doc_file_);
 267                 Params const & params = other.pimpl_->params();
 268                 reset(params.filename, params);
 269         }
 270         return *this;
 271 }
 272
 273
 274 void Loader::reset(FileName const & file, bool display) const
 275 {
 276         Params params;
 277         params.display = display;
 278         pimpl_->resetParams(params);
 279
 280         pimpl_->resetFile(file);
 281         pimpl_->createPixmap();
 282 }
 283
 284
 285 void Loader::reset(FileName const & file, Params const & params) const
 286 {
 287         pimpl_->resetParams(params);
 288         pimpl_->resetFile(file);
 289         pimpl_->createPixmap();
 290 }
 291
 292
 293 void Loader::reset(Params const & params) const
 294 {
 295         pimpl_->resetParams(params);
 296         pimpl_->createPixmap();
 297 }
 298
 299
 300 void Loader::startLoading() const
 301 {
 302         if (pimpl_->status_ != WaitingToLoad || !pimpl_->cached_item_)
 303                 return;
 304         pimpl_->startLoading();
 305 }
 306
 307
 308 void Loader::reload() const
 309 {
 310         pimpl_->cached_item_->startLoading();
 311 }
 312
 313
 314 void Loader::startMonitoring() const
 315 {
 316         if (!pimpl_->cached_item_)
 317                 return;
 318
 319         pimpl_->cached_item_->startMonitoring();
 320 }
 321
 322
 323 bool Loader::monitoring() const
 324 {
 325         if (!pimpl_->cached_item_)
 326                 return false;
 327
 328         return pimpl_->cached_item_->monitoring();
 329 }
 330
 331
 332 void Loader::checkModifiedAsync() const
 333 {
 334         if (!pimpl_->cached_item_)
 335                 return;
 336
 337         pimpl_->cached_item_->checkModifiedAsync();
 338 }
 339
 340
 341 FileName const & Loader::filename() const
 342 {
 343         static FileName const empty;
 344         return pimpl_->cached_item_ ?
 345                 pimpl_->cached_item_->filename() : empty;
 346 }
 347
 348
 349 ImageStatus Loader::status() const
 350 {
 351         return pimpl_->status_;
 352 }
 353
 354
 355 double Loader::displayPixelRatio() const
 356 {
 357         return pimpl_->displayPixelRatio();
 358 }
 359
 360
 361 void Loader::setDisplayPixelRatio(double scale)
 362 {
 363         pimpl_->setDisplayPixelRatio(scale);
 364 }
 365
 366
 367 signals2::connection Loader::connect(slot const & slot) const
 368 {
 369         return pimpl_->signal_.connect(slot);
 370 }
 371
 372
 373 Image const * Loader::image() const
 374 {
 375         return pimpl_->image_.get();
 376 }
 377
 378
 379 Loader::Impl::Impl(FileName const & doc_file)
 380         : doc_file_(doc_file), status_(WaitingToLoad)
 381 {
 382 }
 383
 384
 385 Loader::Impl::~Impl()
 386 {
 387         resetFile(FileName());
 388 }
 389
 390
 391 void Loader::Impl::resetFile(FileName const & file)
 392 {
 393         FileName const old_file = cached_item_ ?
 394                 cached_item_->filename() : FileName();
 395
 396         if (file == old_file)
 397                 return;
 398
 399         // If monitoring() the current file, should continue to monitor the
 400         // new file.
 401         bool continue_monitoring = false;
 402
 403         if (!old_file.empty()) {
 404                 continue_monitoring = cached_item_->monitoring();
 405                 // cached_item_ is going to be reset, so the connected
 406                 // signal needs to be disconnected.
 407                 try {
 408                         // This can in theory throw a BufferException
 409                         connection_.disconnect();
 410                 } catch (...) {
 411                         LYXERR(Debug::GRAPHICS, "Unable to disconnect signal.");
 412                 }
 413                 cached_item_.reset();
 414                 if (status_ != Converting) {
 415                         Cache::get().remove(old_file);
 416                 } else {
 417                         //TODO remove cache item when it is not busy any more, see #7163
 418                 }
 419         }
 420
 421         status_ = cached_item_ ? cached_item_->status() : WaitingToLoad;
 422         image_.reset();
 423
 424         if (cached_item_ || file.empty())
 425                 return;
 426
 427         Cache & gc = Cache::get();
 428         if (!gc.inCache(file))
 429                 gc.add(file, doc_file_);
 430
 431         // We /must/ make a local copy of this.
 432         cached_item_ = gc.item(file);
 433         status_ = cached_item_->status();
 434
 435         if (continue_monitoring && !cached_item_->monitoring())
 436                 cached_item_->startMonitoring();
 437
 438         // This is a scoped connection
 439         connection_ = cached_item_->connect([this](){ statusChanged(); });
 440 }
 441
 442
 443 void Loader::Impl::resetParams(Params const & params)
 444 {
 445         if (params == params_)
 446                 return;
 447
 448         params_ = params;
 449         status_ = cached_item_ ? cached_item_->status() : WaitingToLoad;
 450         image_.reset();
 451 }
 452
 453
 454 void Loader::Impl::statusChanged()
 455 {
 456         status_ = cached_item_ ? cached_item_->status() : WaitingToLoad;
 457         createPixmap();
 458         signal_();
 459 }
 460
 461
 462 void Loader::Impl::createPixmap()
 463 {
 464         if (!params_.display || status_ != Loaded)
 465                 return;
 466
 467         if (!cached_item_) {
 468                 LYXERR(Debug::GRAPHICS, "pixmap not cached yet");
 469                 return;
 470         }
 471
 472         if (!cached_item_->image()) {
 473                 // There must have been a problem reading the file.
 474                 LYXERR(Debug::GRAPHICS, "Graphics file not loaded.");
 475                 return;
 476         }
 477
 478         image_.reset(cached_item_->image()->clone());
 479
 480         if (params_.pixel_ratio == 1.0) {
 481                 string filename = cached_item_->filename().absFileName();
 482                 size_t idx = filename.find_last_of('.');
 483                 if (idx != string::npos && idx > 3) {
 484                         if (filename.substr(idx - 3, 3) == "@2x") {
 485                                 params_.pixel_ratio = 2.0;
 486                         }
 487                 }
 488         }
 489
 490         bool const success = image_->setPixmap(params_);
 491
 492         if (success) {
 493                 status_ = Ready;
 494         } else {
 495                 image_.reset();
 496                 status_ = ErrorGeneratingPixmap;
 497         }
 498 }
 499
 500 void Loader::Impl::startLoading()
 501 {
 502         if (status_ != WaitingToLoad)
 503                 return;
 504
 505         if (cached_item_->tryDisplayFormat()) {
 506                 status_ = Loaded;
 507                 createPixmap();
 508                 return;
 509         }
 510
 511         LoaderQueue::get().touch(cached_item_);
 512 }
 513
 514
 515 } // namespace graphics
 516 } // namespace lyx