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