xref: /AOO41X/main/sot/source/sdstor/stgelem.hxx (revision 40300343e404b6a6d8e6081930a9558aee6d6ff9)

/**************************************************************
 *
 * 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