src/TextCache.h

   1 // -*- C++ -*-
   2 /* This file is part of
   3  * ======================================================
   4  *
   5  *           LyX, The Document Processor
   6  *           Copyright 1995 Matthias Ettrich
   7  *           Copyright 1995-2000 The LyX Team
   8  *
   9  *           This file is Copyright 2000
  10  *           Lars Gullik Bjønnes
  11  *
  12  * ====================================================== */
  13
  14 #ifndef TEXT_CACHE_H
  15 #define TEXT_CACHE_H
  16
  17 #ifdef __GNUG__
  18 #pragma interface
  19 #endif
  20
  21 #include <iosfwd>
  22
  23 #include "LString.h"
  24 #include "lyxtext.h"
  25
  26 using std::ostream;
  27 using std::vector;
  28
  29 class Buffer;
  30
  31 // This is only the very first implemetation and use of the TextCache,
  32 // operations on it needs to be put into a class or a namespace, that part
  33 // is _NOT_ finished so don't bother to come with too many comments on it
  34 // (unless you have some nice ideas on where/how to do it)
  35 //
  36 // I think we need a global TextCache that is common for all BufferViews,
  37 // also the BufferList needs access to the TextCache. Please tell if you
  38 // don't agree.
  39 //
  40 // Q. What are we caching?
  41 // A. We are caching the screen representations (LyXText) of the
  42 //    documents (Buffer,LyXParagraph) for specific BufferView widths.
  43 // Q. Why the cache?
  44 // A. It is not really needed, but it speeds things up a lot
  45 //    when you have more than one document loaded at once since a total
  46 //    rebreak (reformatting) need not be done when switching between
  47 //    documents. When the cache is in function a document only needs to be
  48 //    formatted upon loading and when the with of the BufferView changes.
  49 //    Later it will also be unneccessary to reformat when having two
  50 //    BufferViews of equal width with the same document, a simple copy
  51 //    of the LyXText structure will do.
  52 // Invariant for the TextCache:
  53 //        - The buffer of the text  in the TextCache _must_ exists
  54 //          in the bufferlist.
  55 //        - For a text in the TextCache there _must not_ be an equivalent
  56 //          text in any BufferView. (same buffer and width).
  57 // Among others this mean:
  58 //        - When a document is closed all trace of it must be removed from
  59 //          the TextCache.
  60 // Scenarios:
  61 //    I believe there are only three possible scenarios where the two first
  62 //    are also covered by the third.
  63 //        - The simplest scenario is what we have now, a single
  64 //          BufferView only.
  65 //          o Opening
  66 //            Nothing to do with the TextCache is done when opening a file.
  67 //          o Switching
  68 //            We switch from buffer A to buffer B.
  69 //            * A's text is cached in TextCache.
  70 //            * We make a search for a text in TextCache that fits B
  71 //              (same buffer and same width).
  72 //          o Horizontal resize
  73 //            If the BufferView's width (LyXView) is horizontally changed all
  74 //            the entries in the TextCache are deleted. (This causes
  75 //            reformat of all loaded documents when next viewed)
  76 //          o Close
  77 //            When a buffer is closed we don't have to do anything, because
  78 //            to close a single buffer it is required to only exist in the
  79 //            BufferView and not in the TextCache. Upon LFUN_QUIT we
  80 //            don't really care since everything is deleted anyway.
  81 //        - The next scenario is when we have several BufferViews (in one or
  82 //          more LyXViews) of equal width.
  83 //          o Opening
  84 //            Nothing to do with the TextCache is done when opening a file.
  85 //          o Switching
  86 //            We switch from buffer A to buffer B.
  87 //            * If A is in another Bufferview we do not put it into TextCache.
  88 //              else we put A into TextCache.
  89 //            * If B is viewed in another BufferView we make a copy of its
  90 //              text and use that, else we search in TextCache for a match.
  91 //              (same buffer same width)
  92 //          o Horizontal resize
  93 //            If the BufferView's width (LyXView) is horisontaly changed all
  94 //            the entries in the TextCache is deleted. (This causes
  95 //            reformat of all loaded documents when next viewed)
  96 //          o Close
  97 //        - The last scenario should cover both the previous ones, this time
  98 //          we have several BufferViews (in one or more LyXViews) with no
  99 //          limitations on width. (And if you wonder why the two other
 100 //          senarios are needed... I used them to get to this one.)
 101 //          o Opening
 102 //            Nothing to do with the TextCache is done when opening a file.
 103 //          o Switching
 104 //            We switch from buffer A to buffer B.
 105 //          o Horisontal rezize
 106 //          o Close
 107
 108 /** This class is used to cache generated LyXText's.
 109     The LyXText's is used by the BufferView to visualize the contents
 110     of a buffer and its paragraphs. Instead of deleting the LyXText when
 111     we switch from one document to another we cache it here so that when
 112     we switch back we do not have to reformat. This makes switching very
 113     fast at the expense of a bit higher memory usage.
 114 */
 115 class TextCache {
 116 public:
 117         ///
 118         typedef vector<LyXText*> Cache;
 119         ///
 120         typedef LyXText * value_type;
 121
 122         /** Returns a pointer to a LyXText that fits the provided buffer
 123             and width. Of there is no match 0 is returned. */
 124         LyXText * findFit(Buffer * b, unsigned short p);
 125         /** Lists all the LyXText's currently in the cache.
 126             Uses msg as header for the list. */
 127         void show(ostream & o, string const & msg);
 128         /// Gives info on a single LyXText (buffer and width)
 129         static void show(ostream & o, LyXText *);
 130         /** Adds a LyXText to the cache iff its buffer is
 131             present in bufferlist. */
 132         void add(LyXText *);
 133         /** Clears the cache. Deletes all LyXText's and releases
 134             the allocated memory. */
 135         void clear();
 136         /// Removes all LyXText's that has buffer b from the TextCache
 137         void removeAllWithBuffer(Buffer * b);
 138 private:
 139         /// The cache.
 140         Cache cache;
 141 };
 142
 143 // bla bla
 144 extern TextCache textcache;
 145 #endif