src/ParagraphParameters.C

   1 /**
   2  * \file ParagraphParameters.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  * \author Angus Leeming
   8  * \author John Levon
   9  * \author André Pönitz
  10  * \author Jürgen Vigna
  11  *
  12  * Full author contact details are available in file CREDITS.
  13  */
  14
  15 #include <config.h>
  16
  17 #include "ParagraphParameters.h"
  18
  19 #include "buffer.h"
  20 #include "BufferView.h"
  21 #include "gettext.h"
  22 #include "lyxlayout.h"
  23 #include "lyxlex.h"
  24 #include "lyxtext.h"
  25 #include "paragraph.h"
  26 #include "tex-strings.h"
  27
  28 #include "support/lstrings.h"
  29
  30 #include <sstream>
  31
  32 using lyx::support::rtrim;
  33
  34 using std::istringstream;
  35 using std::ostream;
  36 using std::ostringstream;
  37 using std::string;
  38
  39 // anonym namespace
  40 namespace {
  41 int findToken(char const * const str[], string const & search_token)
  42 {
  43         return search_token == "default" ?
  44                 0 :
  45                 lyx::support::findToken(str, search_token);
  46 }
  47
  48 }
  49
  50
  51 ParagraphParameters::ParagraphParameters()
  52         : noindent_(false),
  53                 start_of_appendix_(false), appendix_(false),
  54           align_(LYX_ALIGN_LAYOUT), depth_(0)
  55 {}
  56
  57
  58 void ParagraphParameters::clear()
  59 {
  60         operator=(ParagraphParameters());
  61 }
  62
  63
  64 ParagraphParameters::depth_type ParagraphParameters::depth() const
  65 {
  66         return depth_;
  67 }
  68
  69
  70 bool ParagraphParameters::sameLayout(ParagraphParameters const & pp) const
  71 {
  72         return align_ == pp.align_
  73                 && spacing_ == pp.spacing_
  74                 && noindent_ == pp.noindent_
  75                 && depth_ == pp.depth_;
  76 }
  77
  78
  79 Spacing const & ParagraphParameters::spacing() const
  80 {
  81         return spacing_;
  82 }
  83
  84
  85 void ParagraphParameters::spacing(Spacing const & s)
  86 {
  87         spacing_ = s;
  88 }
  89
  90
  91 bool ParagraphParameters::noindent() const
  92 {
  93         return noindent_;
  94 }
  95
  96
  97 void ParagraphParameters::noindent(bool ni)
  98 {
  99         noindent_ = ni;
 100 }
 101
 102
 103 LyXAlignment ParagraphParameters::align() const
 104 {
 105         return align_;
 106 }
 107
 108
 109 void ParagraphParameters::align(LyXAlignment la)
 110 {
 111         align_ = la;
 112 }
 113
 114
 115 void ParagraphParameters::depth(depth_type d)
 116 {
 117         depth_ = d;
 118 }
 119
 120
 121 bool ParagraphParameters::startOfAppendix() const
 122 {
 123         return start_of_appendix_;
 124 }
 125
 126
 127 void ParagraphParameters::startOfAppendix(bool soa)
 128 {
 129         start_of_appendix_ = soa;
 130 }
 131
 132
 133 bool ParagraphParameters::appendix() const
 134 {
 135         return appendix_;
 136 }
 137
 138
 139 void ParagraphParameters::appendix(bool a)
 140 {
 141         appendix_ = a;
 142 }
 143
 144
 145 string const & ParagraphParameters::labelString() const
 146 {
 147         return labelstring_;
 148 }
 149
 150
 151 void ParagraphParameters::labelString(string const & ls)
 152 {
 153         labelstring_ = ls;
 154 }
 155
 156
 157 string const & ParagraphParameters::labelWidthString() const
 158 {
 159         return labelwidthstring_;
 160 }
 161
 162
 163 void ParagraphParameters::labelWidthString(string const & lws)
 164 {
 165         labelwidthstring_ = lws;
 166 }
 167
 168
 169 LyXLength const & ParagraphParameters::leftIndent() const
 170 {
 171         return leftindent_;
 172 }
 173
 174
 175 void ParagraphParameters::leftIndent(LyXLength const & li)
 176 {
 177         leftindent_ = li;
 178 }
 179
 180
 181 void ParagraphParameters::read(LyXLex & lex)
 182 {
 183         while (lex.isOK()) {
 184                 lex.nextToken();
 185                 string const token = lex.getString();
 186
 187                 if (token.empty())
 188                         continue;
 189
 190                 if (token[0] != '\\') {
 191                         lex.pushToken(token);
 192                         break;
 193                 }
 194
 195                 if (token == "\\noindent") {
 196                         noindent(true);
 197                 } else if (token == "\\leftindent") {
 198                         lex.next();
 199                         LyXLength value(lex.getString());
 200                         leftIndent(value);
 201                 } else if (token == "\\start_of_appendix") {
 202                         startOfAppendix(true);
 203                 } else if (token == "\\paragraph_spacing") {
 204                         lex.next();
 205                         string const tmp = rtrim(lex.getString());
 206                         if (tmp == "single") {
 207                                 spacing(Spacing(Spacing::Single));
 208                         } else if (tmp == "onehalf") {
 209                                 spacing(Spacing(Spacing::Onehalf));
 210                         } else if (tmp == "double") {
 211                                 spacing(Spacing(Spacing::Double));
 212                         } else if (tmp == "other") {
 213                                 lex.next();
 214                                 spacing(Spacing(Spacing::Other,
 215                                                  lex.getString()));
 216                         } else {
 217                                 lex.printError("Unknown spacing token: '$$Token'");
 218                         }
 219                 } else if (token == "\\align") {
 220                         lex.next();
 221                         int tmpret = findToken(string_align, lex.getString());
 222                         if (tmpret == -1)
 223                                 ++tmpret;
 224                         align(LyXAlignment(1 << tmpret));
 225                 } else if (token == "\\labelwidthstring") {
 226                         lex.eatLine();
 227                         labelWidthString(lex.getString());
 228                 } else {
 229                         lex.pushToken(token);
 230                         break;
 231                 }
 232         }
 233 }
 234
 235
 236 void ParagraphParameters::write(ostream & os) const
 237 {
 238         // Maybe the paragraph has special spacing
 239         spacing().writeFile(os, true);
 240
 241         // The labelwidth string used in lists.
 242         if (!labelWidthString().empty())
 243                 os << "\\labelwidthstring "
 244                    << labelWidthString() << '\n';
 245
 246         // Start of appendix?
 247         if (startOfAppendix())
 248                 os << "\\start_of_appendix\n";
 249
 250         // Noindent?
 251         if (noindent())
 252                 os << "\\noindent\n";
 253
 254         // Do we have a manual left indent?
 255         if (!leftIndent().zero())
 256                 os << "\\leftindent " << leftIndent().asString() << '\n';
 257
 258         // Alignment?
 259         if (align() != LYX_ALIGN_LAYOUT) {
 260                 int h = 0;
 261                 switch (align()) {
 262                 case LYX_ALIGN_LEFT: h = 1; break;
 263                 case LYX_ALIGN_RIGHT: h = 2; break;
 264                 case LYX_ALIGN_CENTER: h = 3; break;
 265                 default: h = 0; break;
 266                 }
 267                 os << "\\align " << string_align[h] << '\n';
 268         }
 269 }
 270
 271
 272 void params2string(Paragraph const & par, string & data)
 273 {
 274         // A local copy
 275         ParagraphParameters params = par.params();
 276
 277         // This needs to be done separately
 278         params.labelWidthString(par.getLabelWidthString());
 279
 280         // Alignment
 281         LyXLayout_ptr const & layout = par.layout();
 282         if (params.align() == LYX_ALIGN_LAYOUT)
 283                 params.align(layout->align);
 284
 285         ostringstream os;
 286         params.write(os);
 287
 288         // Is alignment possible
 289         os << "\\alignpossible " << layout->alignpossible << '\n';
 290
 291         /// set default alignment
 292         os << "\\aligndefault " << layout->align << '\n';
 293
 294         /// paragraph is always in inset. This is redundant.
 295         os << "\\ininset " << 1 << '\n';
 296
 297         data = os.str();
 298 }
 299
 300
 301 /*
 302 bool operator==(ParagraphParameeters const & ps1,
 303                 ParagraphParameeters const & ps2)
 304 {
 305         return
 306                    ps1.spacing == ps2.spacing
 307                 && ps1.noindent == ps2.noindent
 308                 && ps1.align == ps2.align
 309                 && ps1.depth == ps2.depth
 310                 && ps1.start_of_appendix == ps2.start_of_appendix
 311                 && ps1.appendix == ps2.appendix
 312                 && ps1.labelstring == ps2.labelstring
 313                 && ps1.labelwidthstring == ps2.labelwidthstring
 314                 && ps1.leftindent == ps2.leftindent;
 315 }
 316 */