lotuswordpro/source/filter/bento.hxx

   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 #ifndef INCLUDED_LOTUSWORDPRO_SOURCE_FILTER_BENTO_HXX
  57 #define INCLUDED_LOTUSWORDPRO_SOURCE_FILTER_BENTO_HXX
  58
  59 #include <string>
  60 #include <vector>
  61 #include "lwpsvstream.hxx"
  62
  63 #define BEN_CC __stdcall
  64 #ifdef COMP_BENTO
  65 #define BEN_EXPORT __declspec(dllexport)
  66 #else
  67 #define BEN_EXPORT
  68 #endif
  69
  70 #include "ut.hxx"
  71 #include "utlist.hxx"
  72 #include <tools/stream.hxx>
  73 #include <sot/storage.hxx>
  74
  75 namespace OpenStormBento
  76 {
  77
  78 #define BEN_CURR_MAJOR_VERSION 2
  79 #define BEN_CURR_MINOR_VERSION 0
  80 #define BEN_MAGIC_BYTES_SIZE 8
  81 #define BEN_LABEL_SIZE 24
  82
  83 #define BEN_MAGIC_BYTES "\xA4""CM""\xA5""Hdr""\xD7"
  84
  85 enum BenError
  86 {
  87     BenErr_OK = 0,
  88     BenErr_NameConflict = 1,
  89     BenErr_DuplicateObjectID = 2,
  90     BenErr_UnknownBentoFormatVersion = 3,
  91     BenErr_NamedObjectError = 4,
  92     BenErr_NamedObjectIllegalValue = 5,
  93     BenErr_InvalidTOC = 6,
  94     BenErr_64BitOffsetNotSupported = 7,
  95     BenErr_ReadPastEndOfTOC = 8,
  96     BenErr_ContainerWithNoObjects = 9,
  97     BenErr_ObjectWithNoProperties = 10,
  98     BenErr_PropertyWithNoValues = 11,
  99     BenErr_IllegalInMemoryTOC = 12,
 100     BenErr_PropertyAlreadyExists = 13,
 101     BenErr_UnexpectedEndOfFile = 14,
 102     BenErr_InvalidWriteOffset = 15,
 103     BenErr_InvalidImmediateWrite = 16,
 104     BenErr_TOCSeedError = 17,
 105     BenErr_ReadPastEndOfContainer = 18,
 106     BenErr_DuplicateName = 19,
 107     BenErr_BadReferencedList = 20,
 108     BenErr_IllegalContinuedImmediate = 21,
 109     BenErr_NotBentoContainer = 22,
 110     BenErr_PropertyWithMoreThanOneValue = 23
 111
 112     // IMPORTANT - UtStream errors (UtErr_....) are also valid Bento
 113     // errors.  They have codes of 100 and higher.  When, say, a Bento
 114     // container open fails due to an access violation (somebody else, say,
 115     // has it open exclusive), will get a UtErr code.  If define own
 116     // subclass of UtStream (custom handler), can define own error codes--
 117     // those should start at 200
 118 };
 119
 120 UtDefClassP(LtcBenContainer);
 121 UtDefClassP(CBenIDListElmt);
 122 UtDefClassP(CBenObject);
 123 UtDefClassP(CBenProperty);
 124 UtDefClassP(CBenReference);
 125 UtDefClassP(CBenValue);
 126 UtDefClassP(CBenValueSegment);
 127 UtDefClassP(CBenNamedObjectListElmt);
 128 UtDefClassP(CBenNamedObject);
 129 UtDefClassP(CBenPropertyName);
 130 UtDefClassP(CBenTypeName);
 131
 132 typedef unsigned char BenByte;
 133 typedef unsigned short BenWord;
 134 typedef unsigned long BenDWord;
 135
 136 typedef unsigned long BenContainerPos;
 137 typedef unsigned long BenObjectID;
 138 typedef unsigned long BenGeneration;
 139
 140 sal_uLong BenOpenContainer(LwpSvStream * pStream, pLtcBenContainer * ppContainer);
 141
 142 class CBenIDListElmt : public CUtListElmt
 143 {
 144 public: // Internal methods
 145     CBenIDListElmt(BenObjectID ID, pCUtListElmt pPrev) : CUtListElmt(pPrev)
 146       { cID = ID; }
 147     explicit CBenIDListElmt(BenObjectID ID) { cID = ID; }
 148     BenObjectID GetID() { return cID; }
 149
 150 private: // Data
 151     BenObjectID cID;
 152 };
 153
 154 class CBenNamedObjectListElmt : public CUtListElmt
 155 {
 156 public: // Methods
 157     // added to remove warning
 158     explicit CBenNamedObjectListElmt(pCUtListElmt pPrev) : CUtListElmt(pPrev)
 159       { cpNamedObject = nullptr; }
 160     void SetNamedObject(pCBenNamedObject pObj)
 161     {
 162         cpNamedObject = pObj;
 163     }
 164
 165     pCBenNamedObject GetNamedObject() { return cpNamedObject; }
 166
 167 private: // Data
 168     pCBenNamedObject cpNamedObject;
 169 };
 170
 171 class LtcUtBenValueStream : public SvStream
 172 {
 173 public:
 174     explicit LtcUtBenValueStream(pCBenValue pValue);
 175     virtual ~LtcUtBenValueStream() override;
 176
 177 public: // Overridden methods
 178
 179     /* added by  */
 180     sal_uLong GetSize() { return m_ulValueLength; };
 181 protected: // Overridden methods
 182
 183     virtual std::size_t GetData(void* pData, std::size_t nSize) override;
 184     virtual std::size_t PutData(const void* pData, std::size_t nSize) override;
 185     virtual sal_uInt64   SeekPos( sal_uInt64 nPos ) override;
 186     virtual void    SetSize( sal_uInt64 nSize ) override;
 187     virtual void    FlushData() override;
 188
 189 private: // Data
 190     pCBenValue cpValue;
 191     unsigned long cCurrentPosition;
 192
 193     sal_uLong m_ulValueLength;      // Added by , sum of length of all sub-valuesegments
 194 //  void    GetAmountLeft(sal_uLong * pAmtLeft);    useless in SODC
 195 };
 196
 197 class LtcBenContainer
 198 {
 199 public:
 200     BenError Open();
 201     void RegisterPropertyName(const char * sPropertyName,
 202       pCBenPropertyName * ppPropertyName);
 203     // Pass NULL to begin iteration.  Done when returns NULL.
 204     // Objects are returned in order of increasing ID
 205     pCBenObject GetNextObject(pCBenObject pCurrObject);
 206     pCBenObject FindNextObjectWithProperty(pCBenObject pCurrObject,
 207       BenObjectID PropertyID);
 208
 209 public: // Internal methods
 210     explicit LtcBenContainer(LwpSvStream * pStream);
 211     ~LtcBenContainer();
 212
 213     BenError Read(void * pBuffer, unsigned long MaxSize,
 214       unsigned long * pAmtRead);
 215     BenError ReadKnownSize(void * pBuffer, unsigned long Amt);
 216     BenError SeekToPosition(BenContainerPos Pos);
 217     BenError SeekFromEnd(long Offset);
 218
 219     void SetNextAvailObjectID(BenObjectID ID) { cNextAvailObjectID = ID; }
 220     CUtList& GetObjects() { return cObjects; }
 221     CUtList& GetNamedObjects() { return cNamedObjects; }
 222
 223     LtcUtBenValueStream * FindNextValueStreamWithPropertyName(const char * sPropertyName);
 224     LtcUtBenValueStream * FindValueStreamWithPropertyName(const char * sPropertyName);
 225     void CreateGraphicStream(SvStream * &pStream,  const char *pObjectName);
 226
 227     BenError GetSize(sal_uLong * pLength);
 228 private: // Data
 229     CUtOwningList cObjects;
 230     CUtList cNamedObjects;
 231     LwpSvStream * cpStream;
 232     sal_uLong m_ulLength;   // Added for TOCRead.cpp
 233     BenObjectID cNextAvailObjectID; // for new object
 234 };
 235
 236 class CBenObject : public CBenIDListElmt
 237 {
 238 public:
 239     pCBenProperty UseProperty(BenObjectID PropertyID);
 240     pCBenValue UseValue(BenObjectID PropertyID);
 241     pLtcBenContainer GetContainer() { return cpContainer; }
 242 public: // Internal methods
 243     CBenObject(pLtcBenContainer pContainer, BenObjectID ObjectID,
 244       pCUtListElmt pPrev) : CBenIDListElmt(ObjectID, pPrev)
 245       { cpContainer = pContainer; }
 246     CUtList& GetProperties() { return cProperties; }
 247
 248 private: // Data
 249     pLtcBenContainer cpContainer;
 250     CUtOwningList cProperties;
 251 };
 252
 253 class CBenValue : public CBenIDListElmt
 254 {
 255 public:
 256     unsigned long GetValueSize();
 257     void ReadValueData(void * pBuffer,
 258       unsigned long Offset, unsigned long MaxSize, unsigned long * pAmtRead);
 259
 260     pCBenProperty BEN_EXPORT GetProperty() { return cpProperty; }
 261
 262 public: // Internal methods
 263     // added to remove WARNING
 264     explicit CBenValue(BenObjectID TypeID):CBenIDListElmt(TypeID)
 265     {
 266         cpProperty = nullptr;
 267     }
 268
 269     void SetProperty(pCBenProperty pProperty)
 270     {
 271         cpProperty = pProperty;
 272     }
 273
 274     inline pCBenValueSegment GetNextValueSegment(pCBenValueSegment
 275       pCurrValueSegment);
 276     CUtList& GetValueSegments() { return cValueSegments; }
 277
 278 private: // Data
 279     pCBenProperty cpProperty;
 280     CUtOwningList cValueSegments;
 281 };
 282
 283 class CBenProperty : public CBenIDListElmt
 284 {
 285 public:
 286     // In the Apple Bento, a property can have multiple values, each of a
 287     // different type.  But we never use it that way, so in this code a
 288     // property has exactly one value
 289
 290     CBenValue& UseValue() { return cValue; }
 291     pCBenObject GetBenObject() { return cpObject; }
 292     pLtcBenContainer GetContainer() { return GetBenObject()->GetContainer(); }
 293
 294 public: // Internal methods
 295     // changed to remove WARNING here
 296     CBenProperty(pCBenObject pObject, BenObjectID PropertyID,
 297       BenObjectID TypeID, pCUtListElmt pPrevProperty) :
 298       CBenIDListElmt(PropertyID, pPrevProperty), cValue(TypeID)
 299     {
 300         cpObject = pObject;
 301         cValue.SetProperty(this);
 302     }
 303 private: // Data
 304     pCBenObject cpObject;
 305     CBenValue cValue;
 306 };
 307
 308 class CBenValueSegment : public CUtListElmt
 309 {
 310 public: // Internal methods
 311     CBenValueSegment(pCBenValue pValue, BenContainerPos Pos,
 312       unsigned long Size) : CUtListElmt(&pValue->GetValueSegments())
 313       { cpValue = pValue; cImmediate = false; cPos = Pos;
 314       cSize = Size; }
 315     CBenValueSegment(pCBenValue pValue, const void  * pImmData,
 316       unsigned short Size) : CUtListElmt(&pValue->GetValueSegments())
 317       { cpValue = pValue; cImmediate = true;
 318       UtHugeMemcpy(cImmData, pImmData, Size); cSize = Size; }
 319     bool IsImmediate() { return cImmediate; }
 320     BenContainerPos GetPosition() { return cPos; }
 321     unsigned long GetSize() { return cSize; }
 322     BenByte * GetImmediateData() { return cImmData; }
 323
 324 private: // Data
 325     pCBenValue cpValue;
 326     bool cImmediate;
 327     union
 328     {
 329         BenContainerPos cPos;
 330         BenByte cImmData[4];
 331     };
 332     unsigned long cSize;
 333 };
 334
 335 inline pCBenValueSegment CBenValue::GetNextValueSegment(pCBenValueSegment
 336   pCurrValueSegment)
 337 { return static_cast<pCBenValueSegment>( cValueSegments.GetNextOrNULL(pCurrValueSegment) ); }
 338
 339
 340 class CBenNamedObject : public CBenObject
 341 {
 342 public: // Methods
 343     virtual bool IsPropertyName();
 344
 345 public: // Internal methods
 346     CBenNamedObject(pLtcBenContainer pContainer, BenObjectID ObjectID,
 347     pCBenObject pPrevObject, const OString& rName,
 348     pCUtListElmt pPrevNamedObjectListElmt);
 349
 350     const OString& GetName() { return csName; }
 351
 352 private: // Data
 353     OString csName;
 354     CBenNamedObjectListElmt cNameListElmt;
 355 };
 356
 357 class CBenPropertyName : public CBenNamedObject
 358 {
 359 public: // Internal methods
 360     CBenPropertyName(pLtcBenContainer pContainer, BenObjectID ObjectID,
 361     pCBenObject pPrevObject, const OString& rName,
 362     pCUtListElmt pPrevNamedObjectListElmt) :
 363     CBenNamedObject(pContainer, ObjectID, pPrevObject, rName,
 364     pPrevNamedObjectListElmt) { ; }
 365     virtual bool IsPropertyName() override;
 366 };
 367
 368 class CBenTypeName : public CBenNamedObject
 369 {
 370 public: // Internal methods
 371     CBenTypeName(pLtcBenContainer pContainer, BenObjectID ObjectID,
 372     pCBenObject pPrevObject, const OString& rName,
 373     pCUtListElmt pPrevNamedObjectListElmt) :
 374     CBenNamedObject(pContainer, ObjectID, pPrevObject, rName,
 375     pPrevNamedObjectListElmt) { ; }
 376 };
 377
 378 } // end namespace OpenStormBento
 379 #endif
 380
 381 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */