lotuswordpro/source/filter/bencont.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  The Contents of this file are made available subject to the terms of
   5  *  either of the following licenses
   6  *
   7  *         - GNU Lesser General Public License Version 2.1
   8  *         - Sun Industry Standards Source License Version 1.1
   9  *
  10  *  Sun Microsystems Inc., October, 2000
  11  *
  12  *  GNU Lesser General Public License Version 2.1
  13  *  =============================================
  14  *  Copyright 2000 by Sun Microsystems, Inc.
  15  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  16  *
  17  *  This library is free software; you can redistribute it and/or
  18  *  modify it under the terms of the GNU Lesser General Public
  19  *  License version 2.1, as published by the Free Software Foundation.
  20  *
  21  *  This library is distributed in the hope that it will be useful,
  22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  *  Lesser General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU Lesser General Public
  27  *  License along with this library; if not, write to the Free Software
  28  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  29  *  MA  02111-1307  USA
  30  *
  31  *
  32  *  Sun Industry Standards Source License Version 1.1
  33  *  =================================================
  34  *  The contents of this file are subject to the Sun Industry Standards
  35  *  Source License Version 1.1 (the "License"); You may not use this file
  36  *  except in compliance with the License. You may obtain a copy of the
  37  *  License at http://www.openoffice.org/license.html.
  38  *
  39  *  Software provided under this License is provided on an "AS IS" basis,
  40  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  41  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  42  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  43  *  See the License for the specific provisions governing your rights and
  44  *  obligations concerning the Software.
  45  *
  46  *  The Initial Developer of the Original Code is: IBM Corporation
  47  *
  48  *  Copyright: 2008 by IBM Corporation
  49  *
  50  *  All Rights Reserved.
  51  *
  52  *  Contributor(s): _______________________________________
  53  *
  54  *
  55  ************************************************************************/
  56 #include "first.hxx"
  57 #include "tocread.hxx"
  58 #include <algorithm>
  59 #include <osl/diagnose.h>
  60 #include <rtl/string.hxx>
  61
  62 namespace OpenStormBento
  63 {
  64
  65 // String definitions
  66 const char gsBenMagicBytes[] = BEN_MAGIC_BYTES;
  67
  68 /**
  69 *   New bento container from file stream
  70 *   @param  pointer to length of bento file
  71 *   @param  pointer to pointer of Bento Container object
  72 *   @return error code
  73 */
  74 BenError BenOpenContainer(LwpSvStream * pStream, std::unique_ptr<LtcBenContainer>* ppContainer)
  75 {
  76     *ppContainer = nullptr;
  77
  78     if (nullptr == pStream)
  79     {
  80         return BenErr_ContainerWithNoObjects;
  81     }
  82
  83     std::unique_ptr<LtcBenContainer> pContainer(new LtcBenContainer(pStream));
  84     if (pContainer->Open() != BenErr_OK) // delete two inputs
  85     {
  86         return BenErr_InvalidTOC;
  87     }
  88
  89     *ppContainer = std::move(pContainer);
  90     return BenErr_OK;
  91 }
  92
  93 LtcBenContainer::~LtcBenContainer()
  94 {
  95 }
  96
  97 BenError
  98 LtcBenContainer::Open() // delete two inputs
  99 {
 100     BenError Err;
 101     CBenTOCReader TOCReader(this);
 102     if ((Err = TOCReader.ReadLabelAndTOC()) != BenErr_OK)
 103     {
 104         return Err;
 105     }
 106     return BenErr_OK;
 107 }
 108
 109 void
 110 LtcBenContainer::RegisterPropertyName(const char * sPropertyName,
 111   CBenPropertyName ** ppPropertyName)
 112 {
 113     CUtListElmt * pPrevNamedObjectListElmt;
 114     CBenNamedObject * pNamedObject = FindNamedObject(&cNamedObjects,
 115       sPropertyName, &pPrevNamedObjectListElmt);
 116
 117     if (pNamedObject != nullptr)
 118     {
 119         if (! pNamedObject->IsPropertyName())
 120             return;
 121         else *ppPropertyName = static_cast<CBenPropertyName *>(pNamedObject);
 122     }
 123     else
 124     {
 125         CUtListElmt * pPrevObject;
 126         if (FindID(&cObjects, cNextAvailObjectID, &pPrevObject) != nullptr)
 127             return;
 128
 129         *ppPropertyName = new CBenPropertyName(this, cNextAvailObjectID,
 130           pPrevObject, sPropertyName, pPrevNamedObjectListElmt);
 131         ++cNextAvailObjectID;
 132     }
 133 }
 134
 135 CBenObject *
 136 LtcBenContainer::GetNextObject(CBenObject const * pCurrObject)
 137 {
 138     return static_cast<CBenObject *>(cObjects.GetNextOrNULL(pCurrObject));
 139 }
 140
 141 CBenObject *
 142 LtcBenContainer::FindNextObjectWithProperty(CBenObject * pCurrObject,
 143   BenObjectID PropertyID)
 144 {
 145     while ((pCurrObject = GetNextObject(pCurrObject)) != nullptr)
 146         if (pCurrObject->UseProperty(PropertyID) != nullptr)
 147             return pCurrObject;
 148
 149     return nullptr;
 150 }
 151
 152 /**
 153 *   Construction
 154 *   @param  Bento file stream pointer
 155 *   @return
 156 */
 157 LtcBenContainer::LtcBenContainer(LwpSvStream * pStream)
 158     : cNextAvailObjectID(0)
 159 {
 160     cpStream = pStream;
 161     pStream->Seek(STREAM_SEEK_TO_END);
 162     m_ulLength = pStream->Tell();
 163     pStream->Seek(STREAM_SEEK_TO_BEGIN);
 164 }
 165
 166 /**
 167 *   Read buffer for bento file with specified buffer
 168 *   @param  buffer pointer
 169 *   @param  buffer size
 170 *   @param  number of bytes read
 171 */
 172 void LtcBenContainer::Read(void * pBuffer, size_t MaxSize,
 173   size_t* pAmtRead)
 174 {
 175     *pAmtRead = cpStream->Read(pBuffer, MaxSize);
 176 }
 177 /**
 178 *   Read buffer from bento file with specified size
 179 *   @param  buffer pointer
 180 *   @param  number of bytes to be read
 181 *   @return BenError
 182 */
 183 BenError LtcBenContainer::ReadKnownSize(void * pBuffer, size_t Amt)
 184 {
 185     size_t ulLength = cpStream->Read(pBuffer, Amt);
 186     if (ulLength == Amt)
 187     {
 188         return BenErr_OK;
 189     }
 190     return BenErr_ReadPastEndOfContainer;
 191 }
 192 /**
 193 *   Seek to position from the beginning of the bento file
 194 *   @param  position in container file from beginning
 195 */
 196 void LtcBenContainer::SeekToPosition(BenContainerPos Pos)
 197 {
 198     cpStream->Seek(Pos);
 199 }
 200 /**
 201 *   Seek to position compare to end of bento file
 202 *   @param  position in container file from end
 203 */
 204 void LtcBenContainer::SeekFromEnd(tools::Long Offset)
 205 {
 206     cpStream->Seek(STREAM_SEEK_TO_END);
 207     cpStream->SeekRel(Offset);
 208 }
 209 /**
 210 *   Find the next value stream with property name
 211 *   @param  string of property name
 212 *   @return next value stream pointer with the property names
 213 */
 214 LtcUtBenValueStream * LtcBenContainer::FindNextValueStreamWithPropertyName(const char * sPropertyName)
 215 {
 216     CBenPropertyName * pPropertyName(nullptr);
 217     RegisterPropertyName(sPropertyName, &pPropertyName);        // Get property name object
 218
 219     if (nullptr == pPropertyName)
 220         return nullptr;                                            // Property not exist
 221
 222     // Get current object
 223     CBenObject * pObj =FindNextObjectWithProperty(nullptr, pPropertyName->GetID()); // Get next object with same property name
 224     if (nullptr == pObj)
 225         return nullptr;
 226
 227     CBenValue * pValue;
 228     LtcUtBenValueStream * pValueStream;
 229
 230     pValue = pObj->UseValue(pPropertyName->GetID());
 231
 232     pValueStream = new LtcUtBenValueStream(pValue);
 233
 234     return pValueStream;
 235 }
 236
 237 /**
 238 *   Find the unique value stream with property name
 239 *   @param  string of property name
 240 *   @return the only value stream pointer with the property names
 241 */
 242 LtcUtBenValueStream * LtcBenContainer::FindValueStreamWithPropertyName(const char * sPropertyName)
 243 {
 244     return FindNextValueStreamWithPropertyName(sPropertyName);
 245 }
 246
 247 namespace
 248 {
 249     void readDataInBlocks(SvStream& rSt, sal_uInt64 nDLen, std::vector<sal_uInt8>& rData)
 250     {
 251         //read data in blocks as it's more likely large values are simply broken
 252         //and we'll run out of data before we need to realloc
 253         for (sal_uInt64 i = 0; i < nDLen; i+= SAL_MAX_UINT16)
 254         {
 255            size_t nOldSize = rData.size();
 256            size_t nBlock = std::min<size_t>(SAL_MAX_UINT16, nDLen - nOldSize);
 257            rData.resize(nOldSize + nBlock);
 258            size_t nReadBlock = rSt.ReadBytes(rData.data() + nOldSize, nBlock);
 259            if (nBlock != nReadBlock)
 260            {
 261                rData.resize(nOldSize + nReadBlock);
 262                break;
 263            }
 264         }
 265     }
 266 }
 267
 268 /**
 269 *   Find hazily according to object ID
 270 *   @param  pObjectname - format as "GrXX,XXXXXXXX" wherein XX is high part of object ID, and XXXXXXXX is low part
 271 */
 272 std::vector<sal_uInt8> LtcBenContainer::GetGraphicData(const char *pObjectName)
 273 {
 274     std::vector<sal_uInt8> aData;
 275     if (!pObjectName)
 276     {
 277         return aData;
 278     }
 279     // construct the string of property name
 280     OString sSName=OString::Concat(pObjectName) + "-S";
 281     OString sDName=OString::Concat(pObjectName) + "-D";
 282
 283     /* traverse the found properties and construct the stream vectors */
 284     // get S&D's stream and merge them together
 285     std::unique_ptr<SvStream> xS(FindValueStreamWithPropertyName(sSName.getStr()));
 286     std::unique_ptr<SvStream> xD(FindValueStreamWithPropertyName(sDName.getStr()));
 287
 288     sal_uInt64 nDLen = 0;
 289     if (xD)
 290     {
 291         nDLen = xD->TellEnd();
 292     }
 293     sal_uInt64 nSLen = 0;
 294     if (xS)
 295     {
 296         nSLen = xS->TellEnd();
 297     }
 298
 299     sal_uInt64 nLen = nDLen + nSLen;
 300     OSL_ENSURE(nLen > 0, "expected a non-0 length");
 301     // the 'D' stream is NULL or it has invalid length
 302     if (nLen <= 0)
 303     {
 304         return aData;
 305     }
 306
 307     if (xD)
 308     {
 309         readDataInBlocks(*xD, nDLen, aData);
 310         xD.reset();
 311     }
 312     if (xS)
 313     {
 314         readDataInBlocks(*xS, nSLen, aData);
 315         xS.reset();
 316     }
 317
 318     return aData;
 319 }
 320
 321 sal_uInt64 LtcBenContainer::remainingSize() const
 322 {
 323     return m_ulLength - cpStream->Tell();
 324 }
 325
 326 }// end namespace OpenStormBento
 327
 328 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */