src/insets/InsetSeparator.cpp

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