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