src/ParagraphParameters.cpp

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