writerfilter/source/doctok/WW8ResourceModelImpl.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: WW8ResourceModelImpl.cxx,v $
  10  * $Revision: 1.15 $
  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 <WW8ResourceModelImpl.hxx>
  32 #include <resources.hxx>
  33 #include <util.hxx>
  34 #include <WW8OutputWithDepth.hxx>
  35 #include <resourcemodel/TableManager.hxx>
  36 #include <rtl/string.hxx>
  37 #include <resourcemodel/QNameToString.hxx>
  38
  39 namespace writerfilter {
  40
  41 namespace doctok
  42 {
  43 using namespace ::std;
  44
  45
  46 // ------- WW8TableDataHandler ---------
  47
  48 typedef WW8PropertySet::Pointer_t TablePropsPointer_t;
  49
  50 class WW8TableDataHandler : public TableDataHandler<string,
  51                             TablePropsPointer_t>
  52 {
  53 public:
  54     typedef boost::shared_ptr<WW8TableDataHandler> Pointer_t;
  55     virtual void startTable(unsigned int nRows, unsigned int nDepth,
  56                             TablePropsPointer_t pProps);
  57     virtual void endTable();
  58     virtual void startRow(unsigned int nCols,
  59                           TablePropsPointer_t pProps);
  60     virtual void endRow();
  61     virtual void startCell(const string & start, TablePropsPointer_t pProps);
  62     virtual void endCell(const string & end);
  63 };
  64
  65 void WW8TableDataHandler::startTable(unsigned int nRows, unsigned int nDepth,
  66                                      TablePropsPointer_t /*pProps*/)
  67 {
  68     char sBuffer[256];
  69
  70     string tmpStr = "<tabledata.table rows=\"";
  71     snprintf(sBuffer, sizeof(sBuffer), "%d", nRows);
  72     tmpStr += sBuffer;
  73     tmpStr += "\" depth=\"";
  74     snprintf(sBuffer, sizeof(sBuffer), "%d", nDepth);
  75     tmpStr += sBuffer;
  76     tmpStr += "\">";
  77
  78     output.addItem(tmpStr);
  79 }
  80
  81 void WW8TableDataHandler::endTable()
  82 {
  83     output.addItem("</tabledata.table>");
  84 }
  85
  86 void WW8TableDataHandler::startRow
  87 (unsigned int nCols, TablePropsPointer_t /*pProps*/)
  88 {
  89     char sBuffer[256];
  90
  91     snprintf(sBuffer, sizeof(sBuffer), "%d", nCols);
  92     string tmpStr = "<tabledata.row cells=\"";
  93     tmpStr += sBuffer;
  94     tmpStr += "\">";
  95     output.addItem(tmpStr);
  96 }
  97
  98 void WW8TableDataHandler::endRow()
  99 {
 100     output.addItem("</tabledata.row>");
 101 }
 102
 103 void WW8TableDataHandler::startCell(const string & start,
 104                                     TablePropsPointer_t /*pProps*/)
 105 {
 106     output.addItem("<tabledata.cell>");
 107     output.addItem(start);
 108     output.addItem(", ");
 109 }
 110
 111 void WW8TableDataHandler::endCell(const string & end)
 112 {
 113     output.addItem(end);
 114     output.addItem("</tabledata.cell>");
 115 }
 116
 117 // ----- WW8TableDataManager -------------------------------
 118
 119 class WW8TableManager :
 120     public TableManager<string, TablePropsPointer_t>
 121 {
 122     typedef TableDataHandler<string, TablePropsPointer_t>
 123     TableDataHandlerPointer_t;
 124
 125 public:
 126     WW8TableManager();
 127     virtual ~WW8TableManager() {}
 128     virtual void endParagraphGroup();
 129     virtual bool sprm(Sprm & rSprm);
 130 };
 131
 132 WW8TableManager::WW8TableManager()
 133 {
 134     TableDataHandler<string, TablePropsPointer_t>::Pointer_t pHandler(new WW8TableDataHandler());
 135     setHandler(pHandler);
 136 }
 137
 138 bool WW8TableManager::sprm(Sprm & rSprm)
 139 {
 140     TableManager<string, TablePropsPointer_t>::sprm(rSprm);
 141     output.setDepth(getTableDepthNew());
 142     return true;
 143 }
 144
 145 void WW8TableManager::endParagraphGroup()
 146 {
 147     string tmpStr = "<tabledepth depth=\"";
 148     char sBuffer[256];
 149     snprintf(sBuffer, sizeof(sBuffer), "%" SAL_PRIdINT32, getTableDepthNew());
 150     tmpStr += sBuffer;
 151     tmpStr += "\"/>";
 152     output.addItem(tmpStr);
 153     TableManager<string, TablePropsPointer_t>::endParagraphGroup();
 154 }
 155
 156 WW8TableManager gTableManager;
 157
 158
 159 //-------- WW8TableReference -----------------------------------
 160
 161 void WW8TableReference::resolve(Table & /*rHandler*/)
 162 {
 163     output.addItem("<table/>");
 164 }
 165
 166 string WW8TableReference::getType() const
 167 {
 168     return "WW8TableReference";
 169 }
 170
 171 void WW8PropertiesReference::resolve(Properties & rHandler)
 172 {
 173     if (mpPropSet != NULL)
 174     {
 175         //mpPropSet->dump(clog);
 176
 177         if (mpPropSet->isPap())
 178         {
 179             WW8IntValue aValue(mpPropSet->get_istd());
 180
 181             rHandler.attribute(NS_rtf::LN_ISTD, aValue);
 182         }
 183
 184         WW8PropertySetIterator::Pointer_t pIt = mpPropSet->begin();
 185         WW8PropertySetIterator::Pointer_t pItEnd = mpPropSet->end();
 186
 187         try
 188         {
 189             while (! pIt->equal(*pItEnd))
 190             {
 191                 WW8Sprm aSprm(pIt->get());
 192                 rHandler.sprm(aSprm);
 193
 194                 ++(*pIt);
 195             }
 196         }
 197         catch (ExceptionOutOfBounds e)
 198         {
 199         }
 200     }
 201 }
 202
 203 string WW8PropertiesReference::getType() const
 204 {
 205     return "WW8PropertiesReference";
 206 }
 207
 208 WW8BinaryObjReference::WW8BinaryObjReference
 209 (WW8StructBase & rParent, sal_uInt32 nOffset, sal_uInt32 nCount)
 210 : WW8StructBase(rParent, nOffset, nCount)
 211 {
 212 }
 213
 214 WW8BinaryObjReference::WW8BinaryObjReference
 215 (WW8StructBase * pParent, sal_uInt32 nOffset, sal_uInt32 nCount)
 216 : WW8StructBase(pParent, nOffset, nCount)
 217 {
 218 }
 219
 220 WW8BinaryObjReference::WW8BinaryObjReference
 221 (WW8StructBase * pParent)
 222 : WW8StructBase(pParent, 0x0, pParent->getCount())
 223 {
 224 }
 225
 226 WW8BinaryObjReference::WW8BinaryObjReference
 227 (WW8Stream & rStream, sal_uInt32 nOffset, sal_uInt32 nCount)
 228 : WW8StructBase(rStream, nOffset, nCount)
 229 {
 230 }
 231
 232 writerfilter::Reference<BinaryObj>::Pointer_t
 233 WW8BinaryObjReference::getBinary()
 234 {
 235     return writerfilter::Reference<BinaryObj>::Pointer_t
 236         (new WW8BinaryObjReference(*this));
 237 }
 238
 239 void WW8BinaryObjReference::resolve(BinaryObj & rHandler)
 240 {
 241     writerfilter::Reference<Properties>::Pointer_t pRef =
 242         writerfilter::Reference<Properties>::Pointer_t();
 243
 244     if (getCount() > 0)
 245         rHandler.data(get(0), getCount(), pRef);
 246 }
 247
 248 string WW8BinaryObjReference::getType() const
 249 {
 250     return "WW8BinaryObjReference";
 251 }
 252
 253 sal_uInt32 WW8Sprm::getId() const
 254 {
 255     sal_uInt32 nResult = 0;
 256
 257     if (mpProperty.get() != NULL)
 258         nResult = mpProperty->getId();
 259     else if (mpBinary.get() != NULL)
 260         nResult = NS_rtf::LN_blob;
 261
 262     return nResult;
 263 }
 264
 265 string WW8Sprm::toString() const
 266 {
 267     string sResult = "";
 268
 269     if (mpProperty.get() != NULL)
 270         sResult = mpProperty->toString();
 271
 272     return sResult;
 273 }
 274
 275 Value::Pointer_t WW8Sprm::getValue()
 276 {
 277     Value::Pointer_t pResult;
 278
 279     if (mpProperty.get() != NULL)
 280         pResult = Value::Pointer_t(createValue(mpProperty->getParam()));
 281
 282     return pResult;
 283 }
 284
 285 writerfilter::Reference<BinaryObj>::Pointer_t WW8Sprm::getBinary()
 286 {
 287     writerfilter::Reference<BinaryObj>::Pointer_t pResult;
 288
 289     if (mpBinary.get() != NULL)
 290         pResult = writerfilter::Reference<BinaryObj>::Pointer_t
 291             (mpBinary->clone());
 292     else if (mpProperty.get() != NULL)
 293         pResult = createSprmBinary
 294             (dynamic_cast<WW8PropertyImpl &>(*(mpProperty.get())));
 295
 296     return pResult;
 297 }
 298
 299 writerfilter::Reference<Stream>::Pointer_t WW8Sprm::getStream()
 300 {
 301     return writerfilter::Reference<Stream>::Pointer_t();
 302 }
 303
 304 writerfilter::Reference<Properties>::Pointer_t WW8Sprm::getProps()
 305 {
 306     writerfilter::Reference<Properties>::Pointer_t pResult;
 307
 308     if (mpProperty.get() != NULL)
 309     {
 310         pResult = createSprmProps
 311             (dynamic_cast<WW8PropertyImpl &>(*(mpProperty.get())));
 312     }
 313
 314     return pResult;
 315 }
 316
 317 Sprm::Kind WW8Sprm::getKind()
 318 {
 319     return SprmKind(getId());
 320 }
 321
 322 string WW8Sprm::getName() const
 323 {
 324     return (*SprmIdToString::Instance())(getId());
 325 }
 326
 327 int WW8Value::getInt() const
 328 {
 329     return 0;
 330 }
 331
 332 uno::Any WW8Value::getAny() const
 333 {
 334     return uno::Any();
 335 }
 336
 337 ::rtl::OUString WW8Value::getString() const
 338 {
 339     return ::rtl::OUString();
 340 }
 341
 342 string WW8Value::toString() const
 343 {
 344     return string();
 345 }
 346
 347 writerfilter::Reference<Properties>::Pointer_t WW8Value::getProperties()
 348 {
 349     return writerfilter::Reference<Properties>::Pointer_t();
 350 }
 351
 352 writerfilter::Reference<Stream>::Pointer_t WW8Value::getStream()
 353 {
 354     return writerfilter::Reference<Stream>::Pointer_t();
 355 }
 356
 357 writerfilter::Reference<BinaryObj>::Pointer_t WW8Value::getBinary()
 358 {
 359     return writerfilter::Reference<BinaryObj>::Pointer_t();
 360 }
 361
 362 int WW8IntValue::getInt() const
 363 {
 364     return mValue;
 365 }
 366
 367 ::rtl::OUString WW8IntValue::getString() const
 368 {
 369     return ::rtl::OUString::valueOf(static_cast<sal_Int32>(mValue));
 370 }
 371
 372 uno::Any WW8IntValue::getAny() const
 373 {
 374     uno::Any aResult;
 375
 376     aResult <<= static_cast<sal_uInt32>(mValue);
 377
 378     return aResult;
 379 }
 380
 381 string WW8IntValue::toString() const
 382 {
 383     char sBuffer[255];
 384
 385     snprintf(sBuffer, sizeof(sBuffer), "%x", mValue);
 386
 387     return string(sBuffer);
 388 }
 389
 390 WW8Value::Pointer_t createValue(int value)
 391 {
 392     return WW8Value::Pointer_t(new WW8IntValue(value));
 393 }
 394
 395 WW8Value::Pointer_t createValue(WW8Value::Pointer_t value)
 396 {
 397     return value;
 398 }
 399
 400 int WW8StringValue::getInt() const
 401 {
 402     return 0;
 403 }
 404
 405 ::rtl::OUString WW8StringValue::getString() const
 406 {
 407     return mString;
 408 }
 409
 410 uno::Any WW8StringValue::getAny() const
 411 {
 412     uno::Any aResult;
 413
 414     aResult <<= mString;
 415
 416     return aResult;
 417 }
 418
 419 string WW8StringValue::toString() const
 420 {
 421     string result;
 422
 423     sal_uInt32 nCount = mString.getLength();
 424     for (sal_uInt32 n = 0; n < nCount; ++n)
 425     {
 426         if (mString[n] <= 0xff && isprint(mString[n]))
 427         {
 428             sal_Unicode nC = mString[n];
 429
 430             if (nC < 256)
 431                 result += sal::static_int_cast<char>(nC);
 432             else
 433                 result += ".";
 434         }
 435         else
 436         {
 437             char sBuffer[64];
 438
 439             snprintf(sBuffer, sizeof(sBuffer), "\\u%04x", mString[n]);
 440             result += sBuffer;
 441         }
 442     }
 443
 444     return result;
 445 }
 446
 447 WW8Value::Pointer_t createValue(const rtl::OUString & rStr)
 448 {
 449     return WW8Value::Pointer_t(new WW8StringValue(rStr));
 450 }
 451
 452 writerfilter::Reference<Properties>::Pointer_t
 453 WW8PropertiesValue::getProperties()
 454 {
 455     return mRef;
 456 }
 457
 458 string WW8PropertiesValue::toString() const
 459 {
 460     return "properties";
 461 }
 462
 463 writerfilter::Reference<Stream>::Pointer_t WW8StreamValue::getStream()
 464 {
 465     return mRef;
 466 }
 467
 468 string WW8StreamValue::toString() const
 469 {
 470     return "stream";
 471 }
 472
 473 writerfilter::Reference<BinaryObj>::Pointer_t WW8BinaryObjValue::getBinary()
 474 {
 475     return mRef;
 476 }
 477
 478 string WW8BinaryObjValue::toString() const
 479 {
 480     return "binaryObj";
 481 }
 482
 483 WW8Value::Pointer_t createValue
 484 (writerfilter::Reference<Properties>::Pointer_t rRef)
 485 {
 486     return WW8Value::Pointer_t(new WW8PropertiesValue(rRef));
 487 }
 488
 489 WW8Value::Pointer_t createValue(writerfilter::Reference<Stream>::Pointer_t rRef)
 490 {
 491     return WW8Value::Pointer_t(new WW8StreamValue(rRef));
 492 }
 493
 494 WW8Value::Pointer_t createValue
 495 (writerfilter::Reference<BinaryObj>::Pointer_t rRef)
 496 {
 497     return WW8Value::Pointer_t(new WW8BinaryObjValue(rRef));
 498 }
 499
 500
 501 }
 502
 503 }
 504