src/output_docbook.C

   1 /**
   2  * \file output_docbook.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 José Matos
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "output_docbook.h"
  15
  16 #include "buffer.h"
  17 #include "bufferparams.h"
  18 #include "counters.h"
  19 #include "debug.h"
  20 #include "lyxtext.h"
  21 #include "paragraph.h"
  22 #include "paragraph_funcs.h"
  23 #include "ParagraphParameters.h"
  24 #include "sgml.h"
  25
  26 #include "insets/insetcommand.h"
  27
  28 #include "support/lstrings.h"
  29 #include "support/lyxlib.h"
  30 #include "support/tostr.h"
  31 #include "support/types.h"
  32
  33 #ifdef HAVE_LOCALE
  34 #endif
  35
  36 using lyx::pos_type;
  37 using lyx::support::subst;
  38
  39 using std::endl;
  40 using std::ostream;
  41 using std::vector;
  42 using std::string;
  43
  44 namespace {
  45
  46 ParagraphList::const_iterator searchParagraph(ParagraphList::const_iterator const & par,
  47                                               ParagraphList::const_iterator const & pend)
  48 {
  49         ParagraphList::const_iterator p = par + 1;
  50
  51         for( ; p != pend && p->layout()->latextype == LATEX_PARAGRAPH; ++p);
  52
  53         return p;
  54 }
  55
  56
  57 ParagraphList::const_iterator searchCommand(ParagraphList::const_iterator const & par,
  58                                             ParagraphList::const_iterator const & pend)
  59 {
  60         LyXLayout_ptr const & bstyle = par->layout();
  61         ParagraphList::const_iterator p = par + 1;
  62
  63         for( ; p != pend; ++p) {
  64                 LyXLayout_ptr const & style = p->layout();
  65                 if( style->latextype == LATEX_COMMAND && style->commanddepth <= bstyle->commanddepth)
  66                         return p;
  67         }
  68         return pend;
  69 }
  70
  71
  72 ParagraphList::const_iterator searchEnvironment(ParagraphList::const_iterator const & par,
  73                                                 ParagraphList::const_iterator const & pend)
  74 {
  75         LyXLayout_ptr const & bstyle = par->layout();
  76         ParagraphList::const_iterator p = par + 1;
  77         for( ; p != pend; ++p) {
  78                 LyXLayout_ptr const & style = p->layout();
  79                 if( style->latextype == LATEX_COMMAND)
  80                         return p;
  81
  82                 if( style->latextype == LATEX_PARAGRAPH) {
  83                         if (p->params().depth() > par->params().depth())
  84                                 continue;
  85                         return p;
  86                 }
  87
  88                 if(p->params().depth() < par->params().depth())
  89                         return p;
  90
  91                 if( style->latexname() != bstyle->latexname() and p->params().depth() == par->params().depth() )
  92                         return p;
  93         }
  94         return pend;
  95 }
  96
  97
  98 ParagraphList::const_iterator makeParagraph(Buffer const & buf,
  99                                             ostream & os,
 100                                             OutputParams const & runparams,
 101                                             ParagraphList const & paragraphs,
 102                                             ParagraphList::const_iterator const & pbegin,
 103                                             ParagraphList::const_iterator const & pend)
 104 {
 105         for(ParagraphList::const_iterator par = pbegin; par != pend; ++par) {
 106                 sgml::openTag(buf, os, *par);
 107                 par->simpleDocBookOnePar(buf, os, runparams, outerFont(par - paragraphs.begin(), paragraphs));
 108                 sgml::closeTag(os, *par);
 109                 os << '\n';
 110         }
 111         return pend;
 112 }
 113
 114
 115 ParagraphList::const_iterator makeEnvironment(Buffer const & buf,
 116                                               ostream & os,
 117                                               OutputParams const & runparams,
 118                                               ParagraphList const & paragraphs,
 119                                               ParagraphList::const_iterator const & pbegin,
 120                                               ParagraphList::const_iterator const & pend) {
 121         ParagraphList::const_iterator par = pbegin;
 122
 123         LyXLayout_ptr const & defaultstyle = buf.params().getLyXTextClass().defaultLayout();
 124         LyXLayout_ptr const & bstyle = par->layout();
 125         string item_tag;
 126
 127         // Opening outter tag
 128         sgml::openTag(buf, os, *pbegin);
 129         os << '\n';
 130         if (bstyle->latextype == LATEX_ENVIRONMENT and bstyle->innertag() == "CDATA")
 131                 os << "<![CDATA[";
 132
 133         while (par != pend) {
 134                 LyXLayout_ptr const & style = par->layout();
 135                 ParagraphList::const_iterator send;
 136                 string id = par->getDocbookId();
 137                 id = id.empty()? "" : " id = \"" + id + "\"";
 138                 string wrapper = "";
 139                 pos_type sep = 0;
 140
 141                 // Opening inner tag
 142                 switch (bstyle->latextype) {
 143                 case LATEX_ENVIRONMENT:
 144                         if (!bstyle->innertag().empty() and bstyle->innertag() != "CDATA") {
 145                                 sgml::openTag(os, bstyle->innertag());
 146                         }
 147                         break;
 148
 149                 case LATEX_ITEM_ENVIRONMENT:
 150                         if (!bstyle->labeltag().empty()) {
 151                                 sgml::openTag(os, bstyle->innertag());
 152                                 sgml::openTag(os, bstyle->labeltag());
 153                                 sep = par->getFirstWord(buf, os, runparams) + 1;
 154                                 sgml::closeTag(os, bstyle->labeltag());
 155                         }
 156                         wrapper = defaultstyle->latexname();
 157                         sgml::openTag(os, bstyle->itemtag());
 158                 default:
 159                         break;
 160                 }
 161
 162                 switch (style->latextype) {
 163                 case LATEX_ENVIRONMENT:
 164                 case LATEX_ITEM_ENVIRONMENT: {
 165                         if(par->params().depth() == pbegin->params().depth()) {
 166                                 sgml::openTag(os, wrapper, id);
 167                                 par->simpleDocBookOnePar(buf, os, runparams, outerFont(par - paragraphs.begin(), paragraphs), sep);
 168                                 sgml::closeTag(os, wrapper);
 169                                 ++par;
 170                         }
 171                         else {
 172                                 send = searchEnvironment(par, pend);
 173                                 par = makeEnvironment(buf, os, runparams, paragraphs, par,send);
 174                         }
 175                         break;
 176                 }
 177                 case LATEX_PARAGRAPH:
 178                         send = searchParagraph(par, pend);
 179                         par = makeParagraph(buf, os, runparams, paragraphs, par,send);
 180                         break;
 181                 default:
 182                         break;
 183                 }
 184
 185                 // Closing inner tag
 186                 switch (bstyle->latextype) {
 187                 case LATEX_ENVIRONMENT:
 188                         if (!bstyle->innertag().empty() and bstyle->innertag() != "CDATA") {
 189                                 sgml::closeTag(os, bstyle->innertag());
 190                                 os << '\n';
 191                         }
 192                         break;
 193                 case LATEX_ITEM_ENVIRONMENT:
 194                         sgml::closeTag(os, bstyle->itemtag());
 195                         if (!bstyle->labeltag().empty())
 196                                 sgml::closeTag(os, bstyle->innertag());
 197                         break;
 198                 default:
 199                         break;
 200                 }
 201         }
 202
 203         if (bstyle->latextype == LATEX_ENVIRONMENT and bstyle->innertag() == "CDATA")
 204                 os << "]]>";
 205
 206         // Closing outter tag
 207         sgml::closeTag(os, *pbegin);
 208
 209         return pend;
 210 }
 211
 212
 213 ParagraphList::const_iterator makeCommand(Buffer const & buf,
 214                                           ostream & os,
 215                                           OutputParams const & runparams,
 216                                           ParagraphList const & paragraphs,
 217                                           ParagraphList::const_iterator const & pbegin,
 218                                           ParagraphList::const_iterator const & pend)
 219 {
 220         ParagraphList::const_iterator par = pbegin;
 221         LyXLayout_ptr const & bstyle = par->layout();
 222
 223         //Open outter tag
 224         sgml::openTag(buf, os, *pbegin);
 225         os << '\n';
 226
 227         // Label around sectioning number:
 228         if (!bstyle->labeltag().empty()) {
 229                 sgml::openTag(os, bstyle->labeltag());
 230                 os << expandLabel(buf.params().getLyXTextClass(), bstyle, false);
 231                 sgml::closeTag(os, bstyle->labeltag());
 232         }
 233
 234         // Opend inner tag and  close inner tags
 235         sgml::openTag(os, bstyle->innertag());
 236         par->simpleDocBookOnePar(buf, os, runparams,  outerFont(par - paragraphs.begin(), paragraphs));
 237         sgml::closeTag(os, bstyle->innertag());
 238         os << '\n';
 239
 240         ++par;
 241         while (par != pend) {
 242                 LyXLayout_ptr const & style = par->layout();
 243                 ParagraphList::const_iterator send;
 244
 245                 switch (style->latextype) {
 246                 case LATEX_COMMAND: {
 247                         send = searchCommand(par, pend);
 248                         par = makeCommand(buf, os, runparams, paragraphs, par,send);
 249                         break;
 250                 }
 251                 case LATEX_ENVIRONMENT:
 252                 case LATEX_ITEM_ENVIRONMENT: {
 253                         send = searchEnvironment(par, pend);
 254                         par = makeEnvironment(buf, os, runparams, paragraphs, par,send);
 255                         break;
 256                 }
 257                 case LATEX_PARAGRAPH:
 258                         send = searchParagraph(par, pend);
 259                         par = makeParagraph(buf, os, runparams, paragraphs, par,send);
 260                         break;
 261                 default:
 262                         break;
 263                 }
 264         }
 265         // Close outter tag
 266         sgml::closeTag(os, *pbegin);
 267
 268         return pend;
 269 }
 270
 271 } // end anonym namespace
 272
 273
 274 void docbookParagraphs(ParagraphList const & paragraphs,
 275                        Buffer const & buf,
 276                        ostream & os,
 277                        OutputParams const & runparams)
 278 {
 279         ParagraphList::const_iterator par = paragraphs.begin();
 280         ParagraphList::const_iterator pend = paragraphs.end();
 281
 282         while (par != pend) {
 283                 LyXLayout_ptr const & style = par->layout();
 284                 ParagraphList::const_iterator send;
 285
 286                 switch (style->latextype) {
 287                 case LATEX_COMMAND: {
 288                         send = searchCommand(par, pend);
 289                         par = makeCommand(buf, os, runparams, paragraphs, par,send);
 290                         break;
 291                 }
 292                 case LATEX_ENVIRONMENT:
 293                 case LATEX_ITEM_ENVIRONMENT: {
 294                         send = searchEnvironment(par, pend);
 295                         par = makeEnvironment(buf, os, runparams, paragraphs, par,send);
 296                         break;
 297                 }
 298                 case LATEX_PARAGRAPH:
 299                         send = searchParagraph(par, pend);
 300                         par = makeParagraph(buf, os, runparams, paragraphs, par,send);
 301                         break;
 302                 default:
 303                         break;
 304                 }
 305         }
 306 }