src/paragraph_funcs.cpp

   1 /**
   2  * \file paragraph_funcs.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  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "paragraph_funcs.h"
  14
  15 #include "BufferParams.h"
  16 #include "Changes.h"
  17 #include "InsetList.h"
  18 #include "Layout.h"
  19 #include "Paragraph.h"
  20 #include "ParagraphParameters.h"
  21 #include "Text.h"
  22 #include "TextClass.h"
  23
  24 #include "support/debug.h"
  25
  26 #include "support/lassert.h"
  27 #include <boost/next_prior.hpp>
  28
  29 using namespace std;
  30
  31 namespace lyx {
  32
  33 static bool moveItem(Paragraph & fromPar, pos_type fromPos,
  34         Paragraph & toPar, pos_type toPos, BufferParams const & params)
  35 {
  36         // Note: moveItem() does not honour change tracking!
  37         // Therefore, it should only be used for breaking and merging paragraphs
  38
  39         // We need a copy here because the character at fromPos is going to be erased.
  40         Font const tmpFont = fromPar.getFontSettings(params, fromPos);
  41         Change const tmpChange = fromPar.lookupChange(fromPos);
  42
  43         if (Inset * tmpInset = fromPar.getInset(fromPos)) {
  44                 fromPar.releaseInset(fromPos);
  45                 // The inset is not in fromPar any more.
  46                 if (!toPar.insertInset(toPos, tmpInset, tmpFont, tmpChange)) {
  47                         delete tmpInset;
  48                         return false;
  49                 }
  50                 return true;
  51         }
  52
  53         char_type const tmpChar = fromPar.getChar(fromPos);
  54         fromPar.eraseChar(fromPos, false);
  55         toPar.insertChar(toPos, tmpChar, tmpFont, tmpChange);
  56         return true;
  57 }
  58
  59
  60 void breakParagraph(BufferParams const & bparams,
  61                     ParagraphList & pars, pit_type par_offset, pos_type pos,
  62                     bool keep_layout)
  63 {
  64         // create a new paragraph, and insert into the list
  65         ParagraphList::iterator tmp =
  66                 pars.insert(boost::next(pars.begin(), par_offset + 1),
  67                             Paragraph());
  68
  69         Paragraph & par = pars[par_offset];
  70
  71         // remember to set the inset_owner
  72         tmp->setInsetOwner(&par.inInset());
  73         // without doing that we get a crash when typing <Return> at the
  74         // end of a paragraph
  75         tmp->setPlainOrDefaultLayout(bparams.documentClass());
  76
  77         // layout stays the same with latex-environments
  78         if (keep_layout) {
  79                 tmp->setLayout(par.layout());
  80                 tmp->setLabelWidthString(par.params().labelWidthString());
  81                 tmp->params().depth(par.params().depth());
  82         } else if (par.params().depth() > 0) {
  83                 Paragraph const & hook = pars[outerHook(par_offset, pars)];
  84                 tmp->setLayout(hook.layout());
  85                 // not sure the line below is useful
  86                 tmp->setLabelWidthString(par.params().labelWidthString());
  87                 tmp->params().depth(hook.params().depth());
  88         }
  89
  90         bool const isempty = (par.allowEmpty() && par.empty());
  91
  92         if (!isempty && (par.size() > pos || par.empty())) {
  93                 tmp->setLayout(par.layout());
  94                 tmp->params().align(par.params().align());
  95                 tmp->setLabelWidthString(par.params().labelWidthString());
  96
  97                 tmp->params().depth(par.params().depth());
  98                 tmp->params().noindent(par.params().noindent());
  99
 100                 // move everything behind the break position
 101                 // to the new paragraph
 102
 103                 /* Note: if !keepempty, empty() == true, then we reach
 104                  * here with size() == 0. So pos_end becomes - 1. This
 105                  * doesn't cause problems because both loops below
 106                  * enforce pos <= pos_end and 0 <= pos
 107                  */
 108                 pos_type pos_end = par.size() - 1;
 109
 110                 for (pos_type i = pos, j = 0; i <= pos_end; ++i) {
 111                         if (moveItem(par, pos, *tmp, j, bparams)) {
 112                                 ++j;
 113                         }
 114                 }
 115         }
 116
 117         // Move over the end-of-par change information
 118         tmp->setChange(tmp->size(), par.lookupChange(par.size()));
 119         par.setChange(par.size(), Change(bparams.trackChanges ?
 120                                            Change::INSERTED : Change::UNCHANGED));
 121
 122         if (pos) {
 123                 // Make sure that we keep the language when
 124                 // breaking paragraph.
 125                 if (tmp->empty()) {
 126                         Font changed = tmp->getFirstFontSettings(bparams);
 127                         Font const & old = par.getFontSettings(bparams, par.size());
 128                         changed.setLanguage(old.language());
 129                         tmp->setFont(0, changed);
 130                 }
 131
 132                 return;
 133         }
 134
 135         if (!isempty) {
 136                 bool const soa = par.params().startOfAppendix();
 137                 par.params().clear();
 138                 // do not lose start of appendix marker (bug 4212)
 139                 par.params().startOfAppendix(soa);
 140                 par.setPlainOrDefaultLayout(bparams.documentClass());
 141         }
 142
 143         // layout stays the same with latex-environments
 144         if (keep_layout) {
 145                 par.setLayout(tmp->layout());
 146                 par.setLabelWidthString(tmp->params().labelWidthString());
 147                 par.params().depth(tmp->params().depth());
 148         }
 149 }
 150
 151
 152 void breakParagraphConservative(BufferParams const & bparams,
 153         ParagraphList & pars, pit_type par_offset, pos_type pos)
 154 {
 155         // create a new paragraph
 156         Paragraph & tmp = *pars.insert(boost::next(pars.begin(), par_offset + 1),
 157                                        Paragraph());
 158         Paragraph & par = pars[par_offset];
 159
 160         tmp.setInsetOwner(&par.inInset());
 161         tmp.makeSameLayout(par);
 162
 163         LASSERT(pos <= par.size(), /**/);
 164
 165         if (pos < par.size()) {
 166                 // move everything behind the break position to the new paragraph
 167                 pos_type pos_end = par.size() - 1;
 168
 169                 for (pos_type i = pos, j = 0; i <= pos_end; ++i) {
 170                         if (moveItem(par, pos, tmp, j, bparams)) {
 171                                 ++j;
 172                         }
 173                 }
 174                 // Move over the end-of-par change information
 175                 tmp.setChange(tmp.size(), par.lookupChange(par.size()));
 176                 par.setChange(par.size(), Change(bparams.trackChanges ?
 177                                            Change::INSERTED : Change::UNCHANGED));
 178         }
 179 }
 180
 181
 182 void mergeParagraph(BufferParams const & bparams,
 183         ParagraphList & pars, pit_type par_offset)
 184 {
 185         Paragraph & next = pars[par_offset + 1];
 186         Paragraph & par = pars[par_offset];
 187
 188         pos_type pos_end = next.size() - 1;
 189         pos_type pos_insert = par.size();
 190
 191         // the imaginary end-of-paragraph character (at par.size()) has to be
 192         // marked as unmodified. Otherwise, its change is adopted by the first
 193         // character of the next paragraph.
 194         if (par.lookupChange(par.size()).type != Change::UNCHANGED) {
 195                 LYXERR(Debug::CHANGES,
 196                    "merging par with inserted/deleted end-of-par character");
 197                 par.setChange(par.size(), Change(Change::UNCHANGED));
 198         }
 199
 200         Change change = next.lookupChange(next.size());
 201
 202         // move the content of the second paragraph to the end of the first one
 203         for (pos_type i = 0, j = pos_insert; i <= pos_end; ++i) {
 204                 if (moveItem(next, 0, par, j, bparams)) {
 205                         ++j;
 206                 }
 207         }
 208
 209         // move the change of the end-of-paragraph character
 210         par.setChange(par.size(), change);
 211
 212         pars.erase(boost::next(pars.begin(), par_offset + 1));
 213 }
 214
 215
 216 pit_type depthHook(pit_type pit, ParagraphList const & pars, depth_type depth)
 217 {
 218         pit_type newpit = pit;
 219
 220         if (newpit != 0)
 221                 --newpit;
 222
 223         while (newpit != 0 && pars[newpit].getDepth() > depth)
 224                 --newpit;
 225
 226         if (pars[newpit].getDepth() > depth)
 227                 return pit;
 228
 229         return newpit;
 230 }
 231
 232
 233 pit_type outerHook(pit_type par_offset, ParagraphList const & pars)
 234 {
 235         Paragraph const & par = pars[par_offset];
 236
 237         if (par.getDepth() == 0)
 238                 return pars.size();
 239         return depthHook(par_offset, pars, depth_type(par.getDepth() - 1));
 240 }
 241
 242
 243 bool isFirstInSequence(pit_type par_offset, ParagraphList const & pars)
 244 {
 245         Paragraph const & par = pars[par_offset];
 246
 247         pit_type dhook_offset = depthHook(par_offset, pars, par.getDepth());
 248
 249         if (dhook_offset == par_offset)
 250                 return true;
 251
 252         Paragraph const & dhook = pars[dhook_offset];
 253
 254         return dhook.layout() != par.layout()
 255                 || dhook.getDepth() != par.getDepth();
 256 }
 257
 258
 259 void setLabelWidthStringToSequence(pit_type par_offset,
 260         ParagraphList & pars, docstring const & s)
 261 {
 262         Paragraph & par = pars[par_offset];
 263         // Find first of same layout in sequence
 264         while (!isFirstInSequence(par_offset, pars)) {
 265                 par_offset = depthHook(par_offset, pars, par.getDepth());
 266                 par = pars[par_offset];
 267         }
 268
 269         // now apply label width string to every par
 270         // in sequence
 271         pit_type const end = pars.size();
 272         depth_type const depth = par.getDepth();
 273         Layout const & layout = par.layout();
 274         for (pit_type pit = par_offset; pit != end; ++pit) {
 275                 while (pars[pit].getDepth() > depth)
 276                         ++pit;
 277                 if (pars[pit].getDepth() < depth)
 278                         return;
 279                 if (pars[pit].layout() != layout)
 280                         return;
 281                 pars[pit].setLabelWidthString(s);
 282         }
 283 }
 284
 285
 286 int getEndLabel(pit_type p, ParagraphList const & pars)
 287 {
 288         pit_type pit = p;
 289         depth_type par_depth = pars[p].getDepth();
 290         while (pit != pit_type(pars.size())) {
 291                 Layout const & layout = pars[pit].layout();
 292                 int const endlabeltype = layout.endlabeltype;
 293
 294                 if (endlabeltype != END_LABEL_NO_LABEL) {
 295                         if (p + 1 == pit_type(pars.size()))
 296                                 return endlabeltype;
 297
 298                         depth_type const next_depth =
 299                                 pars[p + 1].getDepth();
 300                         if (par_depth > next_depth ||
 301                             (par_depth == next_depth && layout != pars[p + 1].layout()))
 302                                 return endlabeltype;
 303                         break;
 304                 }
 305                 if (par_depth == 0)
 306                         break;
 307                 pit = outerHook(pit, pars);
 308                 if (pit != pit_type(pars.size()))
 309                         par_depth = pars[pit].getDepth();
 310         }
 311         return END_LABEL_NO_LABEL;
 312 }
 313
 314
 315 Font const outerFont(pit_type par_offset, ParagraphList const & pars)
 316 {
 317         depth_type par_depth = pars[par_offset].getDepth();
 318         FontInfo tmpfont = inherit_font;
 319
 320         // Resolve against environment font information
 321         while (par_offset != pit_type(pars.size())
 322                && par_depth
 323                && !tmpfont.resolved()) {
 324                 par_offset = outerHook(par_offset, pars);
 325                 if (par_offset != pit_type(pars.size())) {
 326                         tmpfont.realize(pars[par_offset].layout().font);
 327                         par_depth = pars[par_offset].getDepth();
 328                 }
 329         }
 330
 331         return Font(tmpfont);
 332 }
 333
 334
 335 bool isFullyDeleted(ParagraphList const & pars)
 336 {
 337         pit_type const pars_size = static_cast<pit_type>(pars.size());
 338
 339         // check all paragraphs
 340         for (pit_type pit = 0; pit < pars_size; ++pit) {
 341                 if (!pars[pit].empty())   // prevent assertion failure
 342                         if (!pars[pit].isFullyDeleted(0, pars[pit].size()))
 343                                 return false;
 344         }
 345         return true;
 346 }
 347
 348
 349 void acceptChanges(ParagraphList & pars, BufferParams const & bparams)
 350 {
 351         pit_type pars_size = static_cast<pit_type>(pars.size());
 352
 353         // first, accept changes within each individual paragraph
 354         // (do not consider end-of-par)
 355         for (pit_type pit = 0; pit < pars_size; ++pit) {
 356                 if (!pars[pit].empty())   // prevent assertion failure
 357                         pars[pit].acceptChanges(bparams, 0, pars[pit].size());
 358         }
 359
 360         // next, accept imaginary end-of-par characters
 361         for (pit_type pit = 0; pit < pars_size; ++pit) {
 362                 pos_type pos = pars[pit].size();
 363
 364                 if (pars[pit].isInserted(pos)) {
 365                         pars[pit].setChange(pos, Change(Change::UNCHANGED));
 366                 } else if (pars[pit].isDeleted(pos)) {
 367                         if (pit == pars_size - 1) {
 368                                 // we cannot remove a par break at the end of the last
 369                                 // paragraph; instead, we mark it unchanged
 370                                 pars[pit].setChange(pos, Change(Change::UNCHANGED));
 371                         } else {
 372                                 mergeParagraph(bparams, pars, pit);
 373                                 --pit;
 374                                 --pars_size;
 375                         }
 376                 }
 377         }
 378 }
 379
 380
 381 } // namespace lyx