src/insets/InsetNewline.cpp

   1 /**
   2  * \file InsetNewline.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author John Levon
   7  * \author Jürgen Spitzmüller
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "InsetNewline.h"
  15
  16 #include "Cursor.h"
  17 #include "Dimension.h"
  18 #include "FuncRequest.h"
  19 #include "FuncStatus.h"
  20 #include "Lexer.h"
  21 #include "MetricsInfo.h"
  22 #include "OutputParams.h"
  23 #include "output_xhtml.h"
  24
  25 #include "frontends/Application.h"
  26 #include "frontends/FontMetrics.h"
  27 #include "frontends/Painter.h"
  28
  29 #include "support/debug.h"
  30 #include "support/docstream.h"
  31 #include "support/docstring.h"
  32
  33 using namespace std;
  34
  35 namespace lyx {
  36
  37 InsetNewline::InsetNewline() : Inset(0)
  38 {}
  39
  40
  41 void InsetNewlineParams::write(ostream & os) const
  42 {
  43         switch (kind) {
  44         case InsetNewlineParams::NEWLINE:
  45                 os << "newline";
  46                 break;
  47         case InsetNewlineParams::LINEBREAK:
  48                 os <<  "linebreak";
  49                 break;
  50         }
  51 }
  52
  53
  54 void InsetNewlineParams::read(Lexer & lex)
  55 {
  56         string token;
  57         lex.setContext("InsetNewlineParams::read");
  58         lex >> token;
  59         if (token == "newline")
  60                 kind = InsetNewlineParams::NEWLINE;
  61         else if (token == "linebreak")
  62                 kind = InsetNewlineParams::LINEBREAK;
  63         else
  64                 lex.printError("Unknown kind: `$$Token'");
  65 }
  66
  67
  68 void InsetNewline::write(ostream & os) const
  69 {
  70         os << "Newline ";
  71         params_.write(os);
  72 }
  73
  74
  75 void InsetNewline::read(Lexer & lex)
  76 {
  77         params_.read(lex);
  78         lex >> "\\end_inset";
  79 }
  80
  81
  82 void InsetNewline::metrics(MetricsInfo & mi, Dimension & dim) const
  83 {
  84         frontend::FontMetrics const & fm = theFontMetrics(mi.base.font);
  85         dim.asc = fm.maxAscent();
  86         dim.des = fm.maxDescent();
  87         dim.wid = fm.width('n');
  88 }
  89
  90
  91 void InsetNewline::doDispatch(Cursor & cur, FuncRequest & cmd)
  92 {
  93         switch (cmd.action()) {
  94
  95         case LFUN_INSET_MODIFY: {
  96                 InsetNewlineParams params;
  97                 cur.recordUndo();
  98                 string2params(to_utf8(cmd.argument()), params);
  99                 params_.kind = params.kind;
 100                 break;
 101         }
 102
 103         default:
 104                 Inset::doDispatch(cur, cmd);
 105                 break;
 106         }
 107 }
 108
 109
 110 bool InsetNewline::getStatus(Cursor & cur, FuncRequest const & cmd,
 111         FuncStatus & status) const
 112 {
 113         switch (cmd.action()) {
 114         // we handle these
 115         case LFUN_INSET_MODIFY:
 116                 if (cmd.getArg(0) == "newline") {
 117                         InsetNewlineParams params;
 118                         string2params(to_utf8(cmd.argument()), params);
 119                         status.setOnOff(params_.kind == params.kind);
 120                 }
 121                 status.setEnabled(true);
 122                 return true;
 123         default:
 124                 return Inset::getStatus(cur, cmd, status);
 125         }
 126 }
 127
 128
 129 ColorCode InsetNewline::ColorName() const
 130 {
 131         switch (params_.kind) {
 132                 case InsetNewlineParams::NEWLINE:
 133                         return Color_eolmarker;
 134                         break;
 135                 case InsetNewlineParams::LINEBREAK:
 136                         return Color_pagebreak;
 137                         break;
 138         }
 139         // not really useful, but to avoids gcc complaints
 140         return Color_eolmarker;
 141 }
 142
 143
 144 void InsetNewline::latex(otexstream & os, OutputParams const & rp) const
 145 {
 146         switch (params_.kind) {
 147                 case InsetNewlineParams::NEWLINE:
 148                         if (rp.inTableCell == OutputParams::PLAIN)
 149                                 os << "\\newline\n";
 150                         else
 151                                 os << "\\\\\n";
 152                         break;
 153                 case InsetNewlineParams::LINEBREAK:
 154                         os << "\\linebreak{}\n";
 155                         break;
 156                 default:
 157                         os << "\\\\\n";
 158                         break;
 159         }
 160 }
 161
 162
 163 int InsetNewline::plaintext(odocstringstream & os,
 164         OutputParams const &, size_t) const
 165 {
 166         os << '\n';
 167         return PLAINTEXT_NEWLINE;
 168 }
 169
 170
 171 int InsetNewline::docbook(odocstream & os, OutputParams const &) const
 172 {
 173         os << '\n';
 174         return 0;
 175 }
 176
 177
 178 docstring InsetNewline::xhtml(XHTMLStream & xs, OutputParams const &) const
 179 {
 180         xs << html::CR() << html::CompTag("br") << html::CR();
 181         return docstring();
 182 }
 183
 184
 185 void InsetNewline::draw(PainterInfo & pi, int x, int y) const
 186 {
 187         FontInfo font;
 188         font.setColor(ColorName());
 189
 190         frontend::FontMetrics const & fm = theFontMetrics(pi.base.font);
 191         int const wid = fm.width('n');
 192         int const asc = fm.maxAscent();
 193
 194         int xp[3];
 195         int yp[3];
 196
 197         yp[0] = int(y - 0.875 * asc * 0.75);
 198         yp[1] = int(y - 0.500 * asc * 0.75);
 199         yp[2] = int(y - 0.125 * asc * 0.75);
 200
 201         if (pi.ltr_pos) {
 202                 xp[0] = int(x + wid * 0.375);
 203                 xp[1] = int(x);
 204                 xp[2] = int(x + wid * 0.375);
 205         } else {
 206                 xp[0] = int(x + wid * 0.625);
 207                 xp[1] = int(x + wid);
 208                 xp[2] = int(x + wid * 0.625);
 209         }
 210
 211         pi.pain.lines(xp, yp, 3, ColorName());
 212
 213         yp[0] = int(y - 0.500 * asc * 0.75);
 214         yp[1] = int(y - 0.500 * asc * 0.75);
 215         yp[2] = int(y - asc * 0.75);
 216
 217         if (pi.ltr_pos) {
 218                 xp[0] = int(x);
 219                 xp[1] = int(x + wid);
 220                 xp[2] = int(x + wid);
 221         } else {
 222                 xp[0] = int(x + wid);
 223                 xp[1] = int(x);
 224                 xp[2] = int(x);
 225         }
 226
 227         pi.pain.lines(xp, yp, 3, ColorName());
 228
 229         if (params_.kind == InsetNewlineParams::LINEBREAK) {
 230
 231                 yp[2] = int(y - 0.500 * asc * 0.75);
 232
 233                 if (pi.ltr_pos) {
 234                         xp[0] = int(x + 1.3 * wid);
 235                         xp[1] = int(x + 2 * wid);
 236                         xp[2] = int(x + 2 * wid);
 237                 } else {
 238                         xp[0] = int(x - 0.3 * wid);
 239                         xp[1] = int(x - wid);
 240                         xp[2] = int(x - wid);
 241                 }
 242                 pi.pain.lines(xp, yp, 3, ColorName());
 243
 244                 yp[0] = int(y - 0.875 * asc * 0.75);
 245                 yp[1] = int(y - 0.500 * asc * 0.75);
 246                 yp[2] = int(y - 0.125 * asc * 0.75);
 247
 248                 if (pi.ltr_pos) {
 249                         xp[0] = int(x + 2 * wid * 0.813);
 250                         xp[1] = int(x + 2 * wid);
 251                         xp[2] = int(x + 2 * wid * 0.813);
 252                 } else {
 253                         xp[0] = int(x - wid * 0.625);
 254                         xp[1] = int(x - wid);
 255                         xp[2] = int(x - wid * 0.625);
 256                 }
 257                 pi.pain.lines(xp, yp, 3, ColorName());
 258         }
 259 }
 260
 261
 262 string InsetNewline::contextMenuName() const
 263 {
 264         return "context-newline";
 265 }
 266
 267
 268 void InsetNewline::string2params(string const & in, InsetNewlineParams & params)
 269 {
 270         params = InsetNewlineParams();
 271         if (in.empty())
 272                 return;
 273         istringstream data(in);
 274         Lexer lex;
 275         lex.setStream(data);
 276         lex.setContext("InsetNewline::string2params");
 277         lex >> "newline";
 278         params.read(lex);
 279 }
 280
 281
 282 string InsetNewline::params2string(InsetNewlineParams const & params)
 283 {
 284         ostringstream data;
 285         data << "newline" << ' ';
 286         params.write(data);
 287         return data.str();
 288 }
 289
 290
 291 } // namespace lyx