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