sot/source/sdstor/stgelem.hxx

   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 // This file reflects the structure of MS file elements.
  21 // It is very sensitive to alignment!
  22
  23 #ifndef _STGELEM_HXX
  24 #define _STGELEM_HXX
  25
  26 #include <tools/solar.h>
  27
  28 #include <sot/stg.hxx>
  29
  30 class StgIo;
  31 class SvStream;
  32 class String;
  33
  34 SvStream& operator>>( SvStream&, ClsId& );
  35 SvStream& operator<<( SvStream&, const ClsId& );
  36
  37 class StgHeader
  38 {
  39     static const sal_uInt8 cFATPagesInHeader = 109;
  40
  41     sal_uInt8   cSignature[ 8 ];            // 00 signature (see below)
  42     ClsId       aClsId;                     // 08 Class ID
  43     sal_Int32   nVersion;                   // 18 version number
  44     sal_uInt16  nByteOrder;                 // 1C Unicode byte order indicator
  45     sal_Int16   nPageSize;                  // 1E 1 << nPageSize = block size
  46     sal_Int16   nDataPageSize;              // 20 1 << this size == data block size
  47     sal_uInt8   bDirty;                     // 22 internal dirty flag
  48     sal_uInt8   cReserved[ 9 ];             // 23
  49     sal_Int32   nFATSize;                   // 2C total number of FAT pages
  50     sal_Int32   nTOCstrm;                   // 30 starting page for the TOC stream
  51     sal_Int32   nReserved;                  // 34
  52     sal_Int32   nThreshold;                 // 38 minimum file size for big data
  53     sal_Int32   nDataFAT;                   // 3C page # of 1st data FAT block
  54     sal_Int32   nDataFATSize;               // 40 # of data fat blocks
  55     sal_Int32   nMasterChain;               // 44 chain to the next master block
  56     sal_Int32   nMaster;                    // 48 # of additional master blocks
  57     sal_Int32   nMasterFAT[ cFATPagesInHeader ];            // 4C first [cFATPagesInHeader] master FAT pages
  58 public:
  59     StgHeader();
  60
  61     void  Init();                       // initialize the header
  62     sal_Bool  Load( StgIo& );
  63     sal_Bool  Load( SvStream& );
  64     sal_Bool  Store( StgIo& );
  65     sal_Bool  Check();                      // check the signature and version
  66     short GetByteOrder() const          { return nByteOrder; }
  67     sal_Int32 GetTOCStart() const           { return nTOCstrm; }
  68     void  SetTOCStart( sal_Int32 n );
  69     sal_Int32 GetDataFATStart() const       { return nDataFAT; }
  70     void  SetDataFATStart( sal_Int32 n );
  71     sal_Int32 GetDataFATSize() const        { return nDataFATSize; }
  72     void  SetDataFATSize( sal_Int32 n );
  73     sal_Int32 GetThreshold() const          { return nThreshold; }
  74     short GetPageSize() const           { return nPageSize; }
  75     short GetDataPageSize() const       { return nDataPageSize; }
  76     sal_Int32 GetFATSize() const            { return nFATSize; }
  77     void  SetFATSize( sal_Int32 n );
  78     sal_Int32 GetFATChain() const           { return nMasterChain; }
  79     void  SetFATChain( sal_Int32 n );
  80     sal_Int32 GetMasters() const            { return nMaster; }
  81     void  SetMasters( sal_Int32 n );
  82     short GetFAT1Size() const           { return cFATPagesInHeader; }
  83     const ClsId& GetClassId() const     { return aClsId;        }
  84     sal_Int32 GetFATPage( short ) const;
  85     void  SetFATPage( short, sal_Int32 );
  86 };
  87
  88 enum StgEntryType {                     // dir entry types:
  89     STG_EMPTY     = 0,
  90     STG_STORAGE   = 1,
  91     STG_STREAM    = 2,
  92     STG_LOCKBYTES = 3,
  93     STG_PROPERTY  = 4,
  94     STG_ROOT      = 5
  95 };
  96
  97 enum StgEntryRef {                      // reference blocks:
  98     STG_LEFT      = 0,                  // left
  99     STG_RIGHT     = 1,                  // right
 100     STG_CHILD     = 2,                  // child
 101     STG_DATA      = 3                   // data start
 102 };
 103
 104 enum StgEntryTime {                     // time codes:
 105     STG_MODIFIED  = 0,                  // last modification
 106     STG_ACCESSED  = 1                   // last access
 107 };
 108
 109 #define STGENTRY_SIZE 128
 110
 111 //StructuredStorageDirectoryEntry
 112 class StgEntry {                        // directory enty
 113     sal_uInt16  nName[ 32 ];                // 00 name as WCHAR
 114     sal_uInt16  nNameLen;                   // 40 size of name in bytes including 00H
 115     sal_uInt8   cType;                      // 42 entry type
 116     sal_uInt8   cFlags;                     // 43 0 or 1 (tree balance?)
 117     sal_Int32   nLeft;                      // 44 left node entry
 118     sal_Int32   nRight;                     // 48 right node entry
 119     sal_Int32   nChild;                     // 4C 1st child entry if storage
 120     ClsId   aClsId;                     // 50 class ID (optional)
 121     sal_Int32   nFlags;                     // 60 state flags(?)
 122     sal_Int32   nMtime[ 2 ];                // 64 modification time
 123     sal_Int32   nAtime[ 2 ];                // 6C creation and access time
 124     sal_Int32   nPage1;                     // 74 starting block (either direct or translated)
 125     sal_Int32   nSize;                      // 78 file size
 126     sal_Int32   nUnknown;                   // 7C unknown
 127     String  aName;                      // Name as Compare String (ascii, upper)
 128 public:
 129     sal_Bool    Init();                     // initialize the data
 130     sal_Bool    SetName( const String& );   // store a name (ASCII, up to 32 chars)
 131     void    GetName( String& rName ) const;
 132                                         // fill in the name
 133     short   Compare( const StgEntry& ) const;   // compare two entries
 134     sal_Bool    Load( const void* pBuffer, sal_uInt32 nBufSize );
 135     void    Store( void* );
 136     StgEntryType GetType() const        { return (StgEntryType) cType;  }
 137     sal_Int32   GetStartPage() const        { return nPage1; }
 138     void    SetType( StgEntryType t )   { cType = (sal_uInt8) t;                }
 139     sal_uInt8   GetFlags() const            { return cFlags;                }
 140     void    SetFlags( sal_uInt8 c )         { cFlags = c;                   }
 141     sal_Int32   GetSize() const             { return nSize;                 }
 142     void    SetSize( sal_Int32 n )          { nSize = n;                    }
 143     const   ClsId& GetClassId() const   { return aClsId;                }
 144     void    SetClassId( const ClsId& );
 145     sal_Int32   GetLeaf( StgEntryRef ) const;
 146     void    SetLeaf( StgEntryRef, sal_Int32 );
 147 };
 148
 149
 150 #define STG_FREE    -1L                 // page is free
 151 #define STG_EOF     -2L                 // page is last page in chain
 152 #define STG_FAT     -3L                 // page is FAT page
 153 #define STG_MASTER  -4L                 // page is master FAT page
 154
 155 #endif
 156
 157 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */