xref: /trunk/main/sot/source/sdstor/stgelem.hxx (revision 914d351e5f5b84e4342a86d6ab8d4aca7308b9bd)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// This file reflects the structure of MS file elements.
// It is very sensitive to alignment!

#ifndef _STGELEM_HXX
#define _STGELEM_HXX

#ifndef _TOOLS_SOLAR_H
#include <tools/solar.h>
#endif

#include <sot/stg.hxx>

class StgIo;
class SvStream;
class String;

SvStream& operator>>( SvStream&, ClsId& );
SvStream& operator<<( SvStream&, const ClsId& );

class StgHeader
{
    static const sal_uInt8 cFATPagesInHeader = 109;

    sal_uInt8   cSignature[ 8 ];            // 00 signature (see below)
    ClsId       aClsId;                     // 08 Class ID
    sal_Int32   nVersion;                   // 18 version number
    sal_uInt16  nByteOrder;                 // 1C Unicode byte order indicator
    sal_Int16   nPageSize;                  // 1E 1 << nPageSize = block size
    sal_Int16   nDataPageSize;              // 20 1 << this size == data block size
    sal_uInt8   bDirty;                     // 22 internal dirty flag
    sal_uInt8   cReserved[ 9 ];             // 23
    sal_Int32   nFATSize;                   // 2C total number of FAT pages
    sal_Int32   nTOCstrm;                   // 30 starting page for the TOC stream
    sal_Int32   nReserved;                  // 34
    sal_Int32   nThreshold;                 // 38 minimum file size for big data
    sal_Int32   nDataFAT;                   // 3C page # of 1st data FAT block
    sal_Int32   nDataFATSize;               // 40 # of data fat blocks
    sal_Int32   nMasterChain;               // 44 chain to the next master block
    sal_Int32   nMaster;                    // 48 # of additional master blocks
    sal_Int32   nMasterFAT[ cFATPagesInHeader ];            // 4C first [cFATPagesInHeader] master FAT pages
public:
    StgHeader();

    void  Init();                       // initialize the header
    sal_Bool  Load( StgIo& );
    sal_Bool  Load( SvStream& );
    sal_Bool  Store( StgIo& );
    sal_Bool  Check();                      // check the signature and version
    short GetByteOrder() const          { return nByteOrder; }
    sal_Int32 GetTOCStart() const           { return nTOCstrm; }
    void  SetTOCStart( sal_Int32 n );
    sal_Int32 GetDataFATStart() const       { return nDataFAT; }
    void  SetDataFATStart( sal_Int32 n );
    sal_Int32 GetDataFATSize() const        { return nDataFATSize; }
    void  SetDataFATSize( sal_Int32 n );
    sal_Int32 GetThreshold() const          { return nThreshold; }
    short GetPageSize() const           { return nPageSize; }
    short GetDataPageSize() const       { return nDataPageSize; }
    sal_Int32 GetFATSize() const            { return nFATSize; }
    void  SetFATSize( sal_Int32 n );
    sal_Int32 GetFATChain() const           { return nMasterChain; }
    void  SetFATChain( sal_Int32 n );
    sal_Int32 GetMasters() const            { return nMaster; }
    void  SetMasters( sal_Int32 n );
    short GetFAT1Size() const           { return cFATPagesInHeader; }
    const ClsId& GetClassId() const     { return aClsId;        }
    void  SetClassId( const ClsId& );
    sal_Int32 GetFATPage( short ) const;
    void  SetFATPage( short, sal_Int32 );
};

enum StgEntryType {                     // dir entry types:
    STG_EMPTY     = 0,
    STG_STORAGE   = 1,
    STG_STREAM    = 2,
    STG_LOCKBYTES = 3,
    STG_PROPERTY  = 4,
    STG_ROOT      = 5
};

enum StgEntryRef {                      // reference blocks:
    STG_LEFT      = 0,                  // left
    STG_RIGHT     = 1,                  // right
    STG_CHILD     = 2,                  // child
    STG_DATA      = 3                   // data start
};

enum StgEntryTime {                     // time codes:
    STG_MODIFIED  = 0,                  // last modification
    STG_ACCESSED  = 1                   // last access
};

class StgStream;

#define STGENTRY_SIZE 128

class StgEntry {                        // directory enty
    sal_uInt16  nName[ 32 ];                // 00 name as WCHAR
    sal_Int16   nNameLen;                   // 40 size of name in bytes including 00H
    sal_uInt8   cType;                      // 42 entry type
    sal_uInt8   cFlags;                     // 43 0 or 1 (tree balance?)
    sal_Int32   nLeft;                      // 44 left node entry
    sal_Int32   nRight;                     // 48 right node entry
    sal_Int32   nChild;                     // 4C 1st child entry if storage
    ClsId   aClsId;                     // 50 class ID (optional)
    sal_Int32   nFlags;                     // 60 state flags(?)
    sal_Int32   nMtime[ 2 ];                // 64 modification time
    sal_Int32   nAtime[ 2 ];                // 6C creation and access time
    sal_Int32   nPage1;                     // 74 starting block (either direct or translated)
    sal_Int32   nSize;                      // 78 file size
    sal_Int32   nUnknown;                   // 7C unknown
    String  aName;                      // Name as Compare String (ascii, upper)
public:
    sal_Bool    Init();                     // initialize the data
    sal_Bool    SetName( const String& );   // store a name (ASCII, up to 32 chars)
    void    GetName( String& rName ) const;
                                        // fill in the name
    short   Compare( const StgEntry& ) const;   // compare two entries
    sal_Bool    Load( const void* pBuffer, sal_uInt32 nBufSize );
    void    Store( void* );
    StgEntryType GetType() const        { return (StgEntryType) cType;  }
    sal_Int32   GetStartPage() const        { return nPage1; }
    void    SetType( StgEntryType t )   { cType = (sal_uInt8) t;                }
    sal_uInt8   GetFlags() const            { return cFlags;                }
    void    SetFlags( sal_uInt8 c )         { cFlags = c;                   }
    sal_Int32   GetSize() const             { return nSize;                 }
    void    SetSize( sal_Int32 n )          { nSize = n;                    }
    const   ClsId& GetClassId() const   { return aClsId;                }
    void    SetClassId( const ClsId& );
    sal_Int32   GetLeaf( StgEntryRef ) const;
    void    SetLeaf( StgEntryRef, sal_Int32 );
    const   sal_Int32* GetTime( StgEntryTime ) const;
    void    SetTime( StgEntryTime, sal_Int32* );
};


#define STG_FREE    -1L                 // page is free
#define STG_EOF     -2L                 // page is last page in chain
#define STG_FAT     -3L                 // page is FAT page
#define STG_MASTER  -4L                 // page is master FAT page

#endif