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