writerfilter/source/resourcemodel/resourcemodel.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: resourcemodel.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <stdio.h>
  32 #include <resourcemodel/WW8ResourceModel.hxx>
  33 #include <resourcemodel/TableManager.hxx>
  34 #include <resourcemodel/QNameToString.hxx>
  35 #include <resourcemodel/exceptions.hxx>
  36 #include <resourcemodel/SubSequence.hxx>
  37 #include <resourcemodel/util.hxx>
  38 #include <resourcemodel.hxx>
  39
  40 namespace writerfilter {
  41
  42 class ResourceModelOutputWithDepth : public OutputWithDepth<string>
  43 {
  44 public:
  45     ResourceModelOutputWithDepth()
  46     : OutputWithDepth<string>("<tablegroup>", "</tablegroup>") {}
  47
  48     ~ResourceModelOutputWithDepth() {outputGroup();}
  49
  50     void output(const string & str) const { cout << str << endl; }
  51 };
  52
  53 ResourceModelOutputWithDepth output;
  54
  55 Stream::Pointer_t createStreamHandler()
  56 {
  57     return Stream::Pointer_t(new WW8StreamHandler());
  58 }
  59
  60 void dump(OutputWithDepth<string> & /*o*/, const char * /*name*/,
  61           writerfilter::Reference<Properties>::Pointer_t /*props*/)
  62 {
  63 }
  64
  65 void dump(OutputWithDepth<string> & o, const char * name, sal_uInt32 n)
  66 {
  67     char sBuffer[256];
  68     snprintf(sBuffer, sizeof(sBuffer), "%" SAL_PRIuUINT32, n);
  69     string tmpStr = name;
  70     tmpStr += "=";
  71     tmpStr += sBuffer;
  72
  73     o.addItem(tmpStr);
  74 }
  75
  76 void dump(OutputWithDepth<string> & /*o*/, const char * /*name*/,
  77           const rtl::OUString & /*str*/)
  78 {
  79 }
  80
  81 void dump(OutputWithDepth<string> & /*o*/, const char * /*name*/,
  82           writerfilter::Reference<BinaryObj>::Pointer_t /*binary*/)
  83 {
  84 }
  85
  86 string gInfo = "";
  87 // ------- WW8TableDataHandler ---------
  88
  89 class TablePropsRef : public writerfilter::Reference<Properties>
  90 {
  91 public:
  92     typedef boost::shared_ptr<TablePropsRef> Pointer_t;
  93
  94     TablePropsRef() {}
  95     virtual ~TablePropsRef() {}
  96
  97     virtual void resolve(Properties & /*rHandler*/) {}
  98
  99     virtual string getType() const { return "TableProps"; }
 100     void reset() {}
 101     void insert(Pointer_t /* pTablePropsRef */) {}
 102 };
 103
 104 typedef TablePropsRef::Pointer_t TablePropsRef_t;
 105
 106 class WW8TableDataHandler : public TableDataHandler<string,
 107                             TablePropsRef_t>
 108 {
 109 public:
 110     typedef boost::shared_ptr<WW8TableDataHandler> Pointer_t;
 111     virtual void startTable(unsigned int nRows, unsigned int nDepth,
 112                             TablePropsRef_t pProps);
 113     virtual void endTable();
 114     virtual void startRow(unsigned int nCols,
 115                           TablePropsRef_t pProps);
 116     virtual void endRow();
 117     virtual void startCell(const string & start, TablePropsRef_t pProps);
 118     virtual void endCell(const string & end);
 119 };
 120
 121 void WW8TableDataHandler::startTable(unsigned int nRows, unsigned int nDepth,
 122                                      TablePropsRef_t /*pProps*/)
 123 {
 124     char sBuffer[256];
 125
 126     string tmpStr = "<tabledata.table rows=\"";
 127     snprintf(sBuffer, sizeof(sBuffer), "%d", nRows);
 128     tmpStr += sBuffer;
 129     tmpStr += "\" depth=\"";
 130     snprintf(sBuffer, sizeof(sBuffer), "%d", nDepth);
 131     tmpStr += sBuffer;
 132     tmpStr += "\">";
 133
 134     output.addItem(tmpStr);
 135 }
 136
 137 void WW8TableDataHandler::endTable()
 138 {
 139     output.addItem("</tabledata.table>");
 140 }
 141
 142 void WW8TableDataHandler::startRow
 143 (unsigned int nCols, TablePropsRef_t /*pProps*/)
 144 {
 145     char sBuffer[256];
 146
 147     snprintf(sBuffer, sizeof(sBuffer), "%d", nCols);
 148     string tmpStr = "<tabledata.row cells=\"";
 149     tmpStr += sBuffer;
 150     tmpStr += "\">";
 151     output.addItem(tmpStr);
 152 }
 153
 154 void WW8TableDataHandler::endRow()
 155 {
 156     output.addItem("</tabledata.row>");
 157 }
 158
 159 void WW8TableDataHandler::startCell(const string & start,
 160                                     TablePropsRef_t /*pProps*/)
 161 {
 162     output.addItem("<tabledata.cell>");
 163     output.addItem(start);
 164     output.addItem(", ");
 165 }
 166
 167 void WW8TableDataHandler::endCell(const string & end)
 168 {
 169     output.addItem(end);
 170     output.addItem("</tabledata.cell>");
 171 }
 172
 173 // ----- WW8TableDataManager -------------------------------
 174
 175 class WW8TableManager :
 176     public TableManager<string, TablePropsRef_t>
 177 {
 178     typedef TableDataHandler<string, TablePropsRef_t>
 179     TableDataHandlerPointer_t;
 180
 181 public:
 182     WW8TableManager();
 183     virtual ~WW8TableManager() {}
 184     virtual void endParagraphGroup();
 185     virtual bool sprm(Sprm & rSprm);
 186 };
 187
 188 WW8TableManager::WW8TableManager()
 189 {
 190     TableDataHandler<string, TablePropsRef_t>::Pointer_t pHandler(new WW8TableDataHandler());
 191     setHandler(pHandler);
 192 }
 193
 194 bool WW8TableManager::sprm(Sprm & rSprm)
 195 {
 196     TableManager<string, TablePropsRef_t>::sprm(rSprm);
 197     output.setDepth(getTableDepthNew());
 198     return true;
 199 }
 200
 201 void WW8TableManager::endParagraphGroup()
 202 {
 203     string tmpStr = "<tabledepth depth=\"";
 204     char sBuffer[256];
 205     snprintf(sBuffer, sizeof(sBuffer), "%" SAL_PRIuUINT32, getTableDepthNew());
 206     tmpStr += sBuffer;
 207     tmpStr += "\"/>";
 208     output.addItem(tmpStr);
 209     TableManager<string, TablePropsRef_t>::endParagraphGroup();
 210 }
 211
 212 WW8TableManager gTableManager;
 213
 214 /* WW8StreamHandler */
 215
 216 WW8StreamHandler::WW8StreamHandler()
 217 : mnUTextCount(0)
 218 {
 219     output.closeGroup();
 220     output.addItem("<stream>");
 221     gTableManager.startLevel();
 222 }
 223
 224 WW8StreamHandler::~WW8StreamHandler()
 225 {
 226     gTableManager.endLevel();
 227
 228     output.closeGroup();
 229     output.addItem("</stream>");
 230 }
 231
 232 void WW8StreamHandler::startSectionGroup()
 233 {
 234     output.addItem("<section-group>");
 235 }
 236
 237 void WW8StreamHandler::endSectionGroup()
 238 {
 239     output.addItem("</section-group>");
 240 }
 241
 242 void WW8StreamHandler::startParagraphGroup()
 243 {
 244     output.openGroup();
 245     output.addItem("<paragraph-group>");
 246
 247     gTableManager.startParagraphGroup();
 248     gTableManager.handle(gInfo);
 249 }
 250
 251 void WW8StreamHandler::endParagraphGroup()
 252 {
 253     gTableManager.endParagraphGroup();
 254
 255     output.addItem("</paragraph-group>");
 256     output.closeGroup();
 257
 258 }
 259
 260 void WW8StreamHandler::startCharacterGroup()
 261 {
 262     output.addItem("<character-group>");
 263 }
 264
 265 void WW8StreamHandler::endCharacterGroup()
 266 {
 267     output.addItem("</character-group>");
 268 }
 269
 270 void WW8StreamHandler::text(const sal_uInt8 * data, size_t len)
 271 {
 272     string tmpStr = "<text>";
 273
 274     for (unsigned int n = 0; n < len; ++n)
 275     {
 276         switch (static_cast<unsigned char>(data[n]))
 277         {
 278         case '<':
 279             tmpStr += "&lt;";
 280
 281             break;
 282         case '>':
 283             tmpStr += "&gt;";
 284
 285             break;
 286
 287         case '&':
 288             tmpStr += "&amp;";
 289
 290             break;
 291         default:
 292             if (isprint(data[n]))
 293                 tmpStr += static_cast<char>(data[n]);
 294             else
 295             {
 296                 char sBuffer[256];
 297
 298                 snprintf(sBuffer, sizeof(sBuffer), "\\0x%02x", data[n]);
 299
 300                 tmpStr += sBuffer;
 301             }
 302         }
 303     }
 304
 305     tmpStr += "</text>";
 306
 307     output.addItem(tmpStr);
 308
 309     gTableManager.text(data, len);
 310 }
 311
 312 void WW8StreamHandler::utext(const sal_uInt8 * data, size_t len)
 313 {
 314     static char sBuffer[256];
 315     snprintf(sBuffer, sizeof(sBuffer), "<utext count=\"%d\">", mnUTextCount);
 316     string tmpStr(sBuffer);
 317
 318     for (unsigned int n = 0; n < len; ++n)
 319     {
 320         sal_Unicode nChar = data[n * 2] + (data[n * 2 + 1] << 8);
 321         if (nChar < 0xff && isprint(nChar))
 322         {
 323             switch (nChar)
 324             {
 325             case '&':
 326                 tmpStr += "&amp;";
 327                 break;
 328             case '<':
 329                 tmpStr += "&lt;";
 330                 break;
 331             case '>':
 332                 tmpStr += "&gt;";
 333                 break;
 334             default:
 335                 tmpStr += static_cast<char>(nChar);
 336             }
 337         }
 338         else
 339         {
 340             snprintf(sBuffer, sizeof(sBuffer), "\\0x%04x", nChar);
 341
 342             tmpStr += sBuffer;
 343         }
 344     }
 345
 346     tmpStr += "</utext>";
 347
 348     output.addItem(tmpStr);
 349
 350     gTableManager.utext(data, len);
 351
 352     mnUTextCount++;
 353 }
 354
 355 void WW8StreamHandler::props(writerfilter::Reference<Properties>::Pointer_t ref)
 356 {
 357     WW8PropertiesHandler aHandler;
 358
 359     output.addItem("<properties type=\"" + ref->getType() + "\">");
 360     ref->resolve(aHandler);
 361
 362     //gTableManager.props(ref);
 363
 364     output.addItem("</properties>");
 365 }
 366
 367 void WW8StreamHandler::table(Id name, writerfilter::Reference<Table>::Pointer_t ref)
 368 {
 369     WW8TableHandler aHandler;
 370
 371     output.addItem("<table id=\"" + (*QNameToString::Instance())(name)
 372                    + "\">");
 373
 374     try
 375     {
 376         ref->resolve(aHandler);
 377     }
 378     catch (Exception e)
 379     {
 380         output.addItem("<exception>" + e.getText() + "</exception>");
 381     }
 382
 383     output.addItem("</table>");
 384 }
 385
 386 void WW8StreamHandler::substream(Id name,
 387                                  writerfilter::Reference<Stream>::Pointer_t ref)
 388 {
 389     output.addItem("<substream name=\"" + (*QNameToString::Instance())(name)
 390                    + "\">");
 391
 392     gTableManager.startLevel();
 393
 394     ref->resolve(*this);
 395
 396     gTableManager.endLevel();
 397
 398     output.addItem("</substream>");
 399 }
 400
 401 void WW8StreamHandler::info(const string & info_)
 402 {
 403     gInfo = info_;
 404     output.addItem("<info>" + info_ + "</info>");
 405 }
 406
 407 void WW8PropertiesHandler::attribute(Id name, Value & val)
 408 {
 409     boost::shared_ptr<rtl::OString> pStr(new ::rtl::OString());
 410     ::rtl::OUString aStr = val.getString();
 411     aStr.convertToString(pStr.get(), RTL_TEXTENCODING_ASCII_US,
 412                          OUSTRING_TO_OSTRING_CVTFLAGS);
 413     string sXMLValue = xmlify(pStr->getStr());
 414
 415     char sBuffer[256];
 416     snprintf(sBuffer, sizeof(sBuffer), "0x%x", val.getInt());
 417
 418     output.addItem("<attribute name=\"" +
 419                    (*QNameToString::Instance())(name) +
 420                    "\" value=\"" +
 421                    sXMLValue +
 422                    + "\" hexvalue=\""
 423                    + sBuffer + "\">");
 424
 425     writerfilter::Reference<Properties>::Pointer_t pProps = val.getProperties();
 426
 427     if (pProps.get() != NULL)
 428     {
 429         output.addItem("<properties name=\"" +
 430                        (*QNameToString::Instance())(name)
 431                        + "\" type=\"" + pProps->getType() + "\">");
 432
 433         try
 434         {
 435             pProps->resolve(*this);
 436         }
 437         catch (ExceptionOutOfBounds e)
 438         {
 439         }
 440
 441         output.addItem("</properties>");
 442     }
 443
 444     writerfilter::Reference<Stream>::Pointer_t pStream = val.getStream();
 445
 446     if (pStream.get() != NULL)
 447     {
 448         try
 449         {
 450             WW8StreamHandler aHandler;
 451
 452             pStream->resolve(aHandler);
 453         }
 454         catch (ExceptionOutOfBounds e)
 455         {
 456         }
 457     }
 458
 459     writerfilter::Reference<BinaryObj>::Pointer_t pBinObj = val.getBinary();
 460
 461     if (pBinObj.get() != NULL)
 462     {
 463         try
 464         {
 465             WW8BinaryObjHandler aHandler;
 466
 467             pBinObj->resolve(aHandler);
 468         }
 469         catch (ExceptionOutOfBounds e)
 470         {
 471         }
 472     }
 473
 474     output.addItem("</attribute>");
 475 }
 476
 477 bool WW8PropertiesHandler::compare(SprmSharedPointer_t sprm1,
 478                                    SprmSharedPointer_t sprm2)
 479 {
 480     return sprm1->getId() < sprm2->getId();
 481 }
 482
 483 void WW8PropertiesHandler::sprm(Sprm & sprm_)
 484 {
 485     string tmpStr = "<sprm id=\"";
 486     char buffer[256];
 487     snprintf(buffer, sizeof(buffer), "0x%" SAL_PRIxUINT32, sprm_.getId());
 488     tmpStr += buffer;
 489     tmpStr += "\" name=\"";
 490     tmpStr += sprm_.getName();
 491     tmpStr += "\">";
 492     output.addItem(tmpStr);
 493     output.addItem(sprm_.toString());
 494
 495     writerfilter::Reference<Properties>::Pointer_t pProps = sprm_.getProps();
 496
 497     if (pProps.get() != NULL)
 498     {
 499         output.addItem("<properties type=\"" + pProps->getType() + "\">");
 500         pProps->resolve(*this);
 501         output.addItem("</properties>");
 502     }
 503
 504     writerfilter::Reference<BinaryObj>::Pointer_t pBinObj = sprm_.getBinary();
 505
 506     if (pBinObj.get() != NULL)
 507     {
 508         output.addItem("<binary>");
 509         WW8BinaryObjHandler aHandler;
 510         pBinObj->resolve(aHandler);
 511         output.addItem("</binary>");
 512     }
 513
 514     writerfilter::Reference<Stream>::Pointer_t pStream = sprm_.getStream();
 515
 516     if (pStream.get() != NULL)
 517     {
 518         output.addItem("<stream>");
 519         WW8StreamHandler aHandler;
 520         pStream->resolve(aHandler);
 521         output.addItem("</stream>");
 522     }
 523
 524     gTableManager.sprm(sprm_);
 525
 526     output.addItem("</sprm>");
 527 }
 528
 529 void WW8TableHandler::entry(int /*pos*/,
 530                             writerfilter::Reference<Properties>::Pointer_t ref)
 531 {
 532     output.addItem("<tableentry>");
 533
 534     WW8PropertiesHandler aHandler;
 535
 536     try
 537     {
 538         ref->resolve(aHandler);
 539     }
 540     catch (Exception e)
 541     {
 542         output.addItem("<exception>" + e.getText() + "</exception>");
 543         output.addItem("</tableentry>");
 544
 545         throw e;
 546     }
 547
 548     output.addItem("</tableentry>");
 549 }
 550
 551 void WW8BinaryObjHandler::data
 552 (const sal_uInt8 * buf, size_t length,
 553  writerfilter::Reference<Properties>::Pointer_t /*pRef*/)
 554 {
 555 #if 1
 556     SubSequence<sal_uInt8> aSeq(buf, length);
 557
 558     aSeq.dump(output);
 559 #endif
 560 }
 561
 562 }