writerfilter/source/doctok/WW8PropertySetImpl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "WW8DocumentImpl.hxx"
  21 #include "WW8ResourceModelImpl.hxx"
  22 #include <doctok/resourceids.hxx>
  23 #include <resourcemodel/QNameToString.hxx>
  24
  25 namespace writerfilter {
  26 namespace doctok
  27 {
  28
  29
  30 bool operator != (const WW8PropertySetIterator & rA,
  31                   const WW8PropertySetIterator & rB)
  32 {
  33     return ! (rA.equal(rB));
  34 }
  35
  36 WW8Property::~WW8Property()
  37 {
  38 }
  39
  40 WW8PropertySet::~WW8PropertySet()
  41 {
  42 }
  43
  44 WW8PropertySetIterator::~WW8PropertySetIterator()
  45 {
  46 }
  47
  48 WW8PropertyImpl::WW8PropertyImpl(const WW8StructBase & rBase,
  49                                  sal_uInt32 nOffset,
  50                                  sal_uInt32 nCount)
  51 : WW8StructBase(rBase, nOffset, nCount)
  52 {
  53 }
  54
  55 WW8PropertyImpl::~WW8PropertyImpl()
  56 {
  57 }
  58
  59 sal_uInt32 WW8PropertyImpl::getParam() const
  60 {
  61     sal_uInt32 nResult = 0;
  62
  63     switch (get_spra())
  64     {
  65     case 0:
  66     case 1:
  67         nResult = getU8(2);
  68
  69         break;
  70
  71     case 2:
  72     case 4:
  73     case 5:
  74         nResult = getU16(2);
  75
  76         break;
  77
  78     case 3:
  79         nResult = getU32(2);
  80
  81         break;
  82
  83     case 7:
  84         nResult = getU16(2) + (getU8(4) << 16);
  85
  86         break;
  87
  88     default:
  89         break;
  90     }
  91
  92     return nResult;
  93 }
  94
  95 WW8Stream::Sequence WW8PropertyImpl::getParams() const
  96 {
  97     return WW8Stream::Sequence(mSequence, 2, getCount() - 2);
  98 }
  99
 100 sal_uInt32 WW8PropertyImpl::getByteLength() const
 101 {
 102     sal_uInt32 nParamSize = 0;
 103
 104     switch (get_spra())
 105     {
 106     case 0:
 107     case 1:
 108         nParamSize = 1;
 109
 110         break;
 111
 112     case 2:
 113     case 4:
 114     case 5:
 115         nParamSize = 2;
 116
 117         break;
 118
 119     case 3:
 120         nParamSize = 4;
 121
 122         break;
 123
 124     case 7:
 125         nParamSize = 3;
 126
 127         break;
 128     default:
 129         switch (getId())
 130         {
 131         case 0xd608:
 132                 nParamSize = getU16(2) + 1;
 133                 break;
 134         default:
 135                 nParamSize = getU8(2) + 1;
 136                 break;
 137         }
 138
 139         break;
 140     }
 141
 142     return nParamSize + 2;
 143 }
 144
 145 void WW8PropertyImpl::dump(OutputWithDepth<string> & o) const
 146 {
 147     o.addItem(toString());
 148 }
 149
 150 string WW8PropertyImpl::toString() const
 151 {
 152     string aResult;
 153
 154     aResult += "<sprmcommon";
 155
 156     char sBuffer[256];
 157     snprintf(sBuffer, sizeof(sBuffer), " id=\"%" SAL_PRIuUINT32 "\"", getId());
 158     aResult += sBuffer;
 159     aResult += " name=\"";
 160     aResult += (*SprmIdToString::Instance())(getId());
 161     aResult += "\"";
 162     snprintf(sBuffer, sizeof(sBuffer), " sgc=\"%x\"", get_sgc());
 163     aResult += sBuffer;
 164     snprintf(sBuffer, sizeof(sBuffer), " spra=\"%x\"", get_spra());
 165     aResult += sBuffer;
 166     snprintf(sBuffer, sizeof(sBuffer), " size=\"%" SAL_PRIxUINT32 "\"", getByteLength());
 167     aResult += sBuffer;
 168     snprintf(sBuffer, sizeof(sBuffer), " param=\"%" SAL_PRIxUINT32 "\"", getParam());
 169     aResult += sBuffer;
 170     aResult += ">\n";
 171
 172     aResult += mSequence.toString();
 173
 174     aResult += "</sprmcommon>";
 175
 176     return aResult;
 177 }
 178
 179 WW8PropertySetImpl::WW8PropertySetImpl(WW8Stream & rStream,
 180                                        sal_uInt32 nOffset,
 181                                        sal_uInt32 nCount,
 182                                        bool bPap)
 183 : WW8StructBase(rStream, nOffset, nCount), mbPap(bPap)
 184 {
 185 }
 186
 187 WW8PropertySetImpl::WW8PropertySetImpl(const WW8StructBase & rBase,
 188                                        sal_uInt32 nOffset,
 189                                        sal_uInt32 nCount,
 190                                        bool bPap)
 191 : WW8StructBase(rBase, nOffset, nCount), mbPap(bPap)
 192 {
 193 }
 194
 195 WW8PropertySetImpl::~WW8PropertySetImpl()
 196 {
 197 }
 198
 199 bool WW8PropertySetImpl::isPap() const
 200 {
 201     return mbPap;
 202 }
 203
 204 sal_uInt32 WW8PropertySetImpl::get_istd() const
 205 {
 206     sal_uInt32 nResult = 0;
 207
 208     if (mbPap)
 209         nResult = getU16(0);
 210
 211     return nResult;
 212 }
 213
 214 WW8PropertySetIterator::Pointer_t WW8PropertySetImpl::begin()
 215 {
 216     return WW8PropertySetIterator::Pointer_t
 217         (new WW8PropertySetIteratorImpl(this, mbPap ? 2 : 0));
 218 }
 219
 220 WW8PropertySetIterator::Pointer_t WW8PropertySetImpl::end()
 221 {
 222     return WW8PropertySetIterator::Pointer_t
 223         (new WW8PropertySetIteratorImpl(this, getCount()));
 224 }
 225
 226 WW8PropertySetIteratorImpl::~WW8PropertySetIteratorImpl()
 227 {
 228 }
 229
 230 WW8Property::Pointer_t
 231 WW8PropertySetImpl::getAttribute(sal_uInt32 nOffset) const
 232 {
 233     WW8PropertyImpl aTmpAttr(*this, nOffset, 3);
 234
 235     sal_uInt32 nLength = aTmpAttr.getByteLength();
 236
 237     if (nOffset + nLength > getCount())
 238         nLength = getCount() - nOffset;
 239
 240     return WW8Property::Pointer_t
 241         (new WW8PropertyImpl(*this, nOffset, nLength));
 242 }
 243
 244 void WW8PropertySetImpl::dump(OutputWithDepth<string> & o) const
 245 {
 246     WW8StructBase::dump(o);
 247
 248     WW8PropertySetIterator::Pointer_t pIt =
 249         const_cast<WW8PropertySetImpl *>(this)->begin();
 250     WW8PropertySetIterator::Pointer_t pItEnd =
 251         const_cast<WW8PropertySetImpl *>(this)->end();
 252
 253     while((*pIt) != (*pItEnd))
 254     {
 255         WW8Property::Pointer_t pAttr = pIt->get();
 256
 257         pAttr->dump(o);
 258         ++(*pIt);
 259     }
 260 }
 261
 262 void WW8PropertySetImpl::dots(ostream & o)
 263 {
 264     WW8PropertySetIterator::Pointer_t pIt = begin();
 265     WW8PropertySetIterator::Pointer_t pItEnd = end();
 266
 267     while((*pIt) != (*pItEnd))
 268     {
 269         WW8Property::Pointer_t pAttr = pIt->get();
 270
 271         o << "." << endl;
 272
 273         ++(*pIt);
 274     }
 275 }
 276
 277 string WW8PropertySetImpl::getType() const
 278 {
 279     return "WW8PropertySetImpl";
 280 }
 281
 282 void WW8PropertySetImpl::resolveLocal(Sprm & sprm, Properties & rHandler)
 283 {
 284     switch (sprm.getId())
 285     {
 286     case 0x6a03:
 287         {
 288             Value::Pointer_t pValue = sprm.getValue();
 289             getDocument()->setPicLocation(pValue->getInt());
 290             getDocument()->setPicIsData(false);
 291         }
 292         break;
 293     case 0x806:
 294         {
 295             getDocument()->setPicIsData(true);
 296         }
 297         break;
 298     case 0x6646:
 299         {
 300             WW8Stream::Pointer_t pStream = getDocument()->getDataStream();
 301
 302             if (pStream.get() != NULL)
 303             {
 304                 Value::Pointer_t pValue = sprm.getValue();
 305                 sal_uInt32 nOffset = pValue->getInt();
 306                 WW8StructBase aStruct(*pStream, nOffset, 2);
 307                 sal_uInt16 nCount = aStruct.getU16(0);
 308
 309                 {
 310                     WW8PropertySetImpl * pPropSet =
 311                     new WW8PropertySetImpl(*pStream, nOffset + 2, nCount);
 312
 313                     pPropSet->resolve(rHandler);
 314                 }
 315             }
 316         }
 317         break;
 318     default:
 319         break;
 320     }
 321 }
 322
 323 void WW8PropertySetImpl::resolve(Properties & rHandler)
 324 {
 325     if (getCount() >= (isPap() ? 5U : 3U))
 326     {
 327         WW8PropertySetIterator::Pointer_t pIt = begin();
 328         WW8PropertySetIterator::Pointer_t pItEnd = end();
 329
 330         if (isPap())
 331         {
 332             WW8Value::Pointer_t pValue = createValue(getU16(0));
 333             rHandler.attribute(NS_rtf::LN_ISTD, *pValue);
 334         }
 335
 336         while((*pIt) != (*pItEnd))
 337         {
 338             WW8Sprm aSprm(pIt->get());
 339
 340             rHandler.sprm(aSprm);
 341
 342             resolveLocal(aSprm, rHandler);
 343
 344             ++(*pIt);
 345         }
 346     }
 347 }
 348
 349 WW8PropertySetIterator & WW8PropertySetIteratorImpl::operator++ ()
 350 {
 351     WW8Property::Pointer_t pTmpAttr = mpAttrSet->getAttribute(mnOffset);
 352
 353     mnOffset += dynamic_cast<WW8PropertyImpl *>(pTmpAttr.get())->
 354         getByteLength();
 355
 356     if (mnOffset > mpAttrSet->getCount() ||
 357         mpAttrSet->getCount() - mnOffset < 3)
 358         mnOffset = mpAttrSet->getCount();
 359
 360     return *this;
 361 }
 362
 363 WW8Property::Pointer_t WW8PropertySetIteratorImpl::get() const
 364 {
 365     return mpAttrSet->getAttribute(mnOffset);
 366 }
 367
 368 bool WW8PropertySetIteratorImpl::equal
 369 (const WW8PropertySetIterator & rIt) const
 370 {
 371     const WW8PropertySetIteratorImpl & rMyIt =
 372         dynamic_cast<const WW8PropertySetIteratorImpl &>(rIt);
 373
 374     return mpAttrSet == rMyIt.mpAttrSet && mnOffset == rMyIt.mnOffset;
 375 }
 376
 377 string WW8PropertySetIteratorImpl::toString() const
 378 {
 379     string sResult = "";
 380
 381     char sBuffer[256];
 382
 383     snprintf(sBuffer, sizeof(sBuffer), "(%" SAL_PRIuUINT32 ")", mnOffset);
 384     sResult += sBuffer;
 385
 386     return sResult;
 387 }
 388
 389 }}
 390
 391 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */