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