src/output_xhtml.cpp

   1 /**
   2  * \file output_xhtml.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Richard Heck
   7  *
   8  * This code is based upon output_docbook.cpp
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  */
  12
  13 #include <config.h>
  14
  15 #include "output_xhtml.h"
  16
  17 #include "Buffer.h"
  18 #include "buffer_funcs.h"
  19 #include "BufferParams.h"
  20 #include "Counters.h"
  21 #include "Layout.h"
  22 #include "OutputParams.h"
  23 #include "Paragraph.h"
  24 #include "ParagraphList.h"
  25 #include "ParagraphParameters.h"
  26 #include "sgml.h"
  27 #include "Text.h"
  28 #include "TextClass.h"
  29
  30 #include "support/lassert.h"
  31 #include "support/debug.h"
  32 #include "support/lstrings.h"
  33
  34 #include <boost/next_prior.hpp>
  35 #include <vector>
  36
  37 using namespace std;
  38 using namespace lyx::support;
  39
  40 namespace lyx {
  41
  42 namespace html {
  43
  44 docstring escapeChar(char_type c)
  45 {
  46         docstring str;
  47         switch (c) {
  48         case ' ':
  49                 str += " ";
  50                 break;
  51         case '&':
  52                 str += "&amp;";
  53                 break;
  54         case '<':
  55                 str += "&lt;";
  56                 break;
  57         case '>':
  58                 str += "&gt;";
  59                 break;
  60         default:
  61                 str += c;
  62                 break;
  63         }
  64         return str;
  65 }
  66
  67
  68 // FIXME do something here.
  69 docstring htmlize(docstring const & str) {
  70         return str;
  71 }
  72
  73 // FIXME This needs to be protected somehow.
  74 static vector<string> taglist;
  75
  76 bool openTag(odocstream & os, string const & tag, string const & attr)
  77 {
  78         if (tag.empty())
  79                 return false;
  80         // FIXME This is completely primitive. We need something
  81         // a lot better.
  82         // Now do some checks on nesting of tags.
  83         if (tag == "p")
  84                 if (find(taglist.begin(), taglist.end(), "p") != taglist.end())
  85                         return false;
  86         os << from_ascii("<" + tag + (attr.empty() ? "" : " " + attr) + ">");
  87         taglist.push_back(tag);
  88         return true;
  89 }
  90
  91
  92 bool closeTag(odocstream & os, string const & tag)
  93 {
  94         if (tag.empty())
  95                 return false;
  96         // FIXME Check for proper nesting
  97         if (taglist.empty()){
  98                 LYXERR0("Last tag not found when closing `" << tag << "'!");
  99                 return false;
 100         }
 101         string const & lasttag = taglist.back();
 102         if (lasttag != tag)  {
 103                 LYXERR0("Last tag was `" << lasttag << "' when closing `" << tag << "'!");
 104                 return false;
 105         }
 106         taglist.pop_back();
 107         os << from_ascii("</" + tag + ">");
 108         return true;
 109 }
 110
 111
 112
 113 } // html
 114
 115 namespace {
 116
 117 bool openTag(odocstream & os, Layout const & lay)
 118 {
 119         string const tag = lay.htmltag().empty()
 120                         ? "div" : lay.htmltag();
 121         string const attr = lay.htmlattr().empty()
 122                         ? "class=\"" + to_utf8(lay.name()) + "\"" : lay.htmlattr();
 123         return html::openTag(os, tag, attr);
 124 }
 125
 126
 127 bool closeTag(odocstream & os, Layout const & lay)
 128 {
 129         string const tag = lay.htmltag().empty()
 130                         ? "div" : lay.htmltag();
 131         return html::closeTag(os, tag);
 132 }
 133
 134
 135 bool openLabelTag(odocstream & os, Layout const & lay)
 136 {
 137         string const tag = lay.htmllabel().empty()
 138                         ? "span" : lay.htmllabel();
 139         string const attr = lay.htmllabelattr().empty()
 140                         ? "class=\"" + to_utf8(lay.name()) + "label\"" : lay.htmllabelattr();
 141         return html::openTag(os, tag, attr);
 142 }
 143
 144
 145 bool closeLabelTag(odocstream & os, Layout const & lay)
 146 {
 147         string const tag = lay.htmllabel().empty()
 148                         ? "span" : lay.htmllabel();
 149         return html::closeTag(os, tag);
 150 }
 151
 152
 153 bool openItemTag(odocstream & os, Layout const & lay)
 154 {
 155         string const tag = lay.htmlitem().empty()
 156                         ? "div" : lay.htmlitem();
 157         string const attr = lay.htmlitemattr().empty()
 158                         ? "class=\"" + to_utf8(lay.name()) + "item\"" : lay.htmllabelattr();
 159         return html::openTag(os, tag, attr);
 160 }
 161
 162
 163 bool closeItemTag(odocstream & os, Layout const & lay)
 164 {
 165         string const tag = lay.htmlitem().empty()
 166                         ? "div" : lay.htmlitem();
 167         return html::closeTag(os, tag);
 168 }
 169
 170 ParagraphList::const_iterator searchParagraphHtml(
 171         ParagraphList::const_iterator p,
 172   ParagraphList::const_iterator const & pend)
 173 {
 174         for (++p; p != pend && p->layout().latextype == LATEX_PARAGRAPH; ++p)
 175                 ;
 176
 177         return p;
 178 }
 179
 180
 181 ParagraphList::const_iterator searchEnvironmentHtml(
 182                 ParagraphList::const_iterator const pstart,
 183                 ParagraphList::const_iterator const & pend)
 184 {
 185         ParagraphList::const_iterator p = pstart;
 186         Layout const & bstyle = p->layout();
 187         size_t const depth = p->params().depth();
 188         for (++p; p != pend; ++p) {
 189                 Layout const & style = p->layout();
 190                 // It shouldn't happen that e.g. a section command occurs inside
 191                 // a quotation environment, at a higher depth, but as of 6/2009,
 192                 // it can happen. We pretend that it's just at lowest depth.
 193                 if (style.latextype == LATEX_COMMAND)
 194                         return p;
 195                 // If depth is down, we're done
 196                 if (p->params().depth() < depth)
 197                         return p;
 198                 // If depth is up, we're not done
 199                 if (p->params().depth() > depth)
 200                         continue;
 201                 // Now we know we are at the same depth
 202                 if (style.latextype == LATEX_PARAGRAPH
 203                     || style.latexname() != bstyle.latexname())
 204                         return p;
 205         }
 206         return pend;
 207 }
 208
 209
 210 ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
 211                                             odocstream & os,
 212                                             OutputParams const & runparams,
 213                                             Text const & text,
 214                                             ParagraphList::const_iterator const & pbegin,
 215                                             ParagraphList::const_iterator const & pend)
 216 {
 217         ParagraphList::const_iterator const begin = text.paragraphs().begin();
 218         ParagraphList::const_iterator par = pbegin;
 219         for (; par != pend; ++par) {
 220                 Layout const & lay = par->layout();
 221                 if (!lay.counter.empty())
 222                         buf.params().documentClass().counters().step(lay.counter);
 223                 // FIXME We should see if there's a label to be output and
 224                 // do something with it.
 225                 if (par != pbegin)
 226                         os << '\n';
 227                 bool const opened = openTag(os, lay);
 228                 docstring const deferred = par->simpleLyXHTMLOnePar(buf, os, runparams,
 229                                 text.outerFont(distance(begin, par)));
 230                 if (opened) {
 231                         closeTag(os, lay);
 232                         os << '\n';
 233                 }
 234                 if (!deferred.empty())
 235                         os << deferred << '\n';
 236         }
 237         return pend;
 238 }
 239
 240
 241 ParagraphList::const_iterator makeBibliography(Buffer const & buf,
 242                                 odocstream & os,
 243                                 OutputParams const & runparams,
 244                                 Text const & text,
 245                                 ParagraphList::const_iterator const & pbegin,
 246                                 ParagraphList::const_iterator const & pend)
 247 {
 248         os << "<h2 class='bibliography'>"
 249            << pbegin->layout().labelstring(false)
 250            << "</h2>\n"
 251            << "<div class='bibliography'>\n";
 252                         makeParagraphs(buf, os, runparams, text, pbegin, pend);
 253         os << "</div>";
 254         return pend;
 255 }
 256
 257
 258 namespace {
 259         bool isNormalEnv(Layout const & lay)
 260         {
 261                 return lay.latextype == LATEX_ENVIRONMENT;
 262         }
 263 }
 264
 265 ParagraphList::const_iterator makeEnvironmentHtml(Buffer const & buf,
 266                                               odocstream & os,
 267                                               OutputParams const & runparams,
 268                                               Text const & text,
 269                                               ParagraphList::const_iterator const & pbegin,
 270                                               ParagraphList::const_iterator const & pend)
 271 {
 272         ParagraphList::const_iterator const begin = text.paragraphs().begin();
 273         ParagraphList::const_iterator par = pbegin;
 274         Layout const & bstyle = par->layout();
 275         depth_type const origdepth = pbegin->params().depth();
 276
 277         // Open tag for this environment
 278         bool const main_tag_opened = openTag(os, bstyle);
 279         os << '\n';
 280
 281         // we will on occasion need to remember a layout from before.
 282         Layout const * lastlay = 0;
 283
 284         while (par != pend) {
 285                 Layout const & style = par->layout();
 286                 // the counter only gets stepped if we're in some kind of list,
 287                 // or if it's the first time through.
 288                 if (!style.counter.empty() && (par == pbegin || !isNormalEnv(style)))
 289                         buf.params().documentClass().counters().step(style.counter);
 290                 ParagraphList::const_iterator send;
 291                 // this will be positive, if we want to skip the initial word
 292                 // (if it's been taken for the label).
 293                 pos_type sep = 0;
 294
 295                 switch (style.latextype) {
 296                 case LATEX_ENVIRONMENT:
 297                 case LATEX_LIST_ENVIRONMENT:
 298                 case LATEX_ITEM_ENVIRONMENT: {
 299                         // There are two possiblities in this case.
 300                         // One is that we are still in the environment in which we
 301                         // started---which we will be if the depth is the same.
 302                         if (par->params().depth() == origdepth) {
 303                                 LASSERT(bstyle == style, /* */);
 304                                 if (lastlay != 0) {
 305                                         closeItemTag(os, *lastlay);
 306                                         lastlay = 0;
 307                                 }
 308                                 bool item_tag_opened = false;
 309                                 bool const labelfirst = style.htmllabelfirst();
 310                                 if (isNormalEnv(style)) {
 311                                         // in this case, we print the label only for the first
 312                                         // paragraph (as in a theorem).
 313                                         item_tag_opened = openItemTag(os, style);
 314                                         if (par == pbegin) {
 315                                                 docstring const lbl =
 316                                                                 pbegin->expandLabel(style, buf.params(), false);
 317                                                 if (!lbl.empty()) {
 318                                                         bool const label_tag_opened = openLabelTag(os, style);
 319                                                         os << lbl;
 320                                                         if (label_tag_opened)
 321                                                                 closeLabelTag(os, style);
 322                                                 }
 323                                                 os << '\n';
 324                                         }
 325                                 }       else { // some kind of list
 326                                         if (!labelfirst)
 327                                                 item_tag_opened = openItemTag(os, style);
 328                                         if (style.labeltype == LABEL_MANUAL) {
 329                                                 bool const label_tag_opened = openLabelTag(os, style);
 330                                                 sep = par->firstWordLyXHTML(os, runparams);
 331                                                 if (label_tag_opened)
 332                                                         closeLabelTag(os, style);
 333                                                 os << '\n';
 334                                         }
 335                                         else if (style.labeltype != LABEL_NO_LABEL) {
 336                                                 bool const label_tag_opened = openLabelTag(os, style);
 337                                                 os << par->expandLabel(style, buf.params(), false);
 338                                                 if (label_tag_opened)
 339                                                         closeLabelTag(os, style);
 340                                                 os << '\n';
 341                                         }
 342                                         if (labelfirst)
 343                                                 item_tag_opened = openItemTag(os, style);
 344                                         else
 345                                                 os << "<span class='item'>";
 346                                 }
 347                                 par->simpleLyXHTMLOnePar(buf, os, runparams,
 348                                         text.outerFont(distance(begin, par)), sep);
 349                                 if (!isNormalEnv(style) && labelfirst)
 350                                         os << "</span>";
 351                                 ++par;
 352                                 if (item_tag_opened) {
 353                                         // We may not want to close the tag yet, in particular,
 354                                         // if we're not at the end...
 355                                         if (par != pend
 356                                     //  and are doing items...
 357                                      && style.latextype == LATEX_ITEM_ENVIRONMENT
 358                                      // and if the depth has changed...
 359                                      && par->params().depth() != origdepth) {
 360                                      // then we'll save this layout for later, and close it when
 361                                      // we get another item.
 362                                                 lastlay = &style;
 363                                         } else
 364                                                 closeItemTag(os, style);
 365                                         os << '\n';
 366                                 }
 367                         }
 368                         // The other possibility is that the depth has increased, in which
 369                         // case we need to recurse.
 370                         else {
 371                                 send = searchEnvironmentHtml(par, pend);
 372                                 par = makeEnvironmentHtml(buf, os, runparams, text, par, send);
 373                         }
 374                         break;
 375                 }
 376                 case LATEX_PARAGRAPH:
 377                         send = searchParagraphHtml(par, pend);
 378                         par = makeParagraphs(buf, os, runparams, text, par, send);
 379                         break;
 380                 // Shouldn't happen
 381                 case LATEX_BIB_ENVIRONMENT:
 382                         send = par;
 383                         ++send;
 384                         par = makeParagraphs(buf, os, runparams, text, par, send);
 385                         break;
 386                 // Shouldn't happen
 387                 case LATEX_COMMAND:
 388                         ++par;
 389                         break;
 390                 }
 391         }
 392
 393         if (lastlay != 0)
 394                 closeItemTag(os, *lastlay);
 395         if (main_tag_opened)
 396                 closeTag(os, bstyle);
 397         os << '\n';
 398         return pend;
 399 }
 400
 401
 402 void makeCommand(Buffer const & buf,
 403                                           odocstream & os,
 404                                           OutputParams const & runparams,
 405                                           Text const & text,
 406                                           ParagraphList::const_iterator const & pbegin)
 407 {
 408         Layout const & style = pbegin->layout();
 409         if (!style.counter.empty())
 410                 buf.params().documentClass().counters().step(style.counter);
 411
 412         bool const main_tag_opened = openTag(os, style);
 413
 414         // Label around sectioning number:
 415         // FIXME Probably need to account for LABEL_MANUAL
 416         if (style.labeltype != LABEL_NO_LABEL) {
 417                 bool const label_tag_opened = openLabelTag(os, style);
 418                 os << pbegin->expandLabel(style, buf.params(), false);
 419                 if (label_tag_opened)
 420                         closeLabelTag(os, style);
 421                 // Otherwise the label might run together with the text
 422                 os << ' ';
 423         }
 424
 425         ParagraphList::const_iterator const begin = text.paragraphs().begin();
 426         pbegin->simpleLyXHTMLOnePar(buf, os, runparams,
 427                         text.outerFont(distance(begin, pbegin)));
 428         if (main_tag_opened)
 429                 closeTag(os, style);
 430         os << '\n';
 431 }
 432
 433 } // end anonymous namespace
 434
 435
 436 void xhtmlParagraphs(Text const & text,
 437                        Buffer const & buf,
 438                        odocstream & os,
 439                        OutputParams const & runparams)
 440 {
 441         ParagraphList const & paragraphs = text.paragraphs();
 442         ParagraphList::const_iterator par = paragraphs.begin();
 443         ParagraphList::const_iterator pend = paragraphs.end();
 444
 445         while (par != pend) {
 446                 Layout const & style = par->layout();
 447                 ParagraphList::const_iterator lastpar = par;
 448                 ParagraphList::const_iterator send;
 449
 450                 switch (style.latextype) {
 451                 case LATEX_COMMAND: {
 452                         // The files with which we are working never have more than
 453                         // one paragraph in a command structure.
 454                         makeCommand(buf, os, runparams, text, par);
 455                         ++par;
 456                         break;
 457                 }
 458                 case LATEX_ENVIRONMENT:
 459                 case LATEX_LIST_ENVIRONMENT:
 460                 case LATEX_ITEM_ENVIRONMENT: {
 461                         send = searchEnvironmentHtml(par, pend);
 462                         par = makeEnvironmentHtml(buf, os, runparams, text, par, send);
 463                         break;
 464                 }
 465                 case LATEX_BIB_ENVIRONMENT: {
 466                         send = searchEnvironmentHtml(par, pend);
 467                         par = makeBibliography(buf, os, runparams, text, par, send);
 468                         break;
 469                 }
 470                 case LATEX_PARAGRAPH:
 471                         send = searchParagraphHtml(par, pend);
 472                         par = makeParagraphs(buf, os, runparams, text, par, send);
 473                         break;
 474                 }
 475                 // FIXME??
 476                 // makeEnvironment may process more than one paragraphs and bypass pend
 477                 if (distance(lastpar, par) >= distance(lastpar, pend))
 478                         break;
 479         }
 480 }
 481
 482
 483 } // namespace lyx