The said:
Branco, did you have any luck finding an old backup CD / DVD?
Hi! Sorry for the delay.
Yeps, sort of.
I did find an old DVD with what seems to be the code I used.
From what I gathered (oh, boy, reading that code sure brought back
memories...!) you would need a modified type library for StdOle2 (not
sure of this, read on) and the actual type library for the IStdStorage
stuff. Maybe that could be a single tlib with everything in it, I
really can't remember why I used two separate tlibs... probably
because I was developing other things that needed the stdole stuff,
but I'm really not sure.
I'm hoping the modified StdOle2 tlib isn't really needed -- it's not
like you'll be dealing directly with IUnknown and IDispatch. Therefore
I'm posting only the IStorage stuff. If it seems to you that the
modified StdOle2 lib is also needed, drop a line and I'll post it here
-- it needs major edits so to prevent line wraps and I'm really trying
to avoid having to do that, since it's somewhat big =)))
As I said before, those tlibs are used by the compiler only, not by
your final application, so the only place where you'd need then is in
your development machine (** notice however that I have an extremely
fuzzy recolection of the whole echillada, therefore I may be uttering
nonsense, here. For instance, I can't remember, for the life of me,
how did I manage to compile the odl files -- which I do remember
writing -- and also how to indicate to VB that they were supposed to
be used **)
In the odl file, if you ever use it, you'll notice a -- probably
annoying -- tendency of mine of "refactoring" most parameter names,
field names and enumerator names, so they have a more VB-like flavour.
What can I say, I was young and actually hated C/C++ (the platforms
towards which the original object naming was target). This means that
you may have a *somewhat* difficulty to map the online documentation
to the actual interfaces in my tlib... =))
As an example of the level of un-VB-isms involved in dealing with
IStorage files, check out this code fragment I digged from one of the
test modules in the DVD:
<vbclassic>
Sub ListItems(ByRef Source As IStorage)
Dim objEnum As IEnumSTATSTG
Dim dStat As TStatSTG
Dim sName As String
Dim lResult As Long
Dim lCount As Long
Dim lItems As Long
If Source Is Nothing Then
Debug.Print "Storage is not open"
Else
Call Source.Stat(dStat, comDefaultStats)
With dStat
sName = SysAllocString(.NamePtr)
Call CoTaskMemFree(.NamePtr)
End With
Debug.Print "Contents of " & sName & ":"
Call Source.EnumElements(0, 0, 0, objEnum)
Do While lResult = 0
lResult = objEnum.Next(1, dStat, lCount)
If lResult = 0 Then
With dStat
sName = SysAllocString(.NamePtr)
Call CoTaskMemFree(.NamePtr)
Debug.Print vbTab & sName;
Select Case .Type
Case comStorage
Debug.Print vbTab & "Storage"
Case comStream
Debug.Print vbTab & "Stream";
Debug.Print vbTab & .SizeLSB & " bytes"
Case comLockBytes
Debug.Print vbTab & "LockBytes"
Case comProperty
Debug.Print vbTab & "Property"
Case Else
Debug.Print vbTab & "Unknown type"
End Select
End With
lItems = lItems + 1
End If
Loop
Debug.Print "Items found: " & lItems
Set objEnum = Nothing
End If
End Sub
</vbclassic>
Well, hope you can take any value from this.
Best Regards,
Branco.
The odl file. It was saved as VBCOMObjects.odl. That means you
probably can name it anythingyoulike.odl. Oh, and you will have to
compile it to a tlib. Don't look at me, I have no recollection of how
to do that:
[
uuid(CC66FD20-DD0A-11d4-8CF1-080039010D55),
version(1.0),
helpstring("COM Objects for Visual Basic")
]
library VBCOMObjects
{
importlib("STDOLE2.TLB");
typedef enum
{
comDefaultCommit = 0,
comOverwrite = 1,
comOnlyIfCurrent = 2,
comCommitToCacheOnly = 4
} ECommitFlags;
typedef enum
{
comStorage = 1,
comStream = 2,
comLockBytes = 3,
comProperty = 4
} EStorageTypes;
typedef enum
{
comFromStart = 0,
comFromCurrent = 1,
comFromEnd = 2
} ESeekOrigin;
typedef enum
{
comLockWrite = 1,
comLockExclusive = 2,
comLockOnlyOnce = 4
} ELockType;
typedef enum
{
comDefaultStats = 0,
comNoName = 1
} EStatFlags;
typedef enum
{
comDirectMode = 0x00000000,
comTransactedMode = 0x00010000,
comSimpleMode = 0x08000000
} EStgMode;
typedef enum
{
comReadAccess = 0x00000000,
comWriteAccess = 0x00000001,
comReadWriteAccess = 0x00000002
} EStgAccess;
typedef enum
{
comShareDenyNone = 0x00000040,
comShareDenyRead = 0x00000030,
comShareDenyWrite = 0x00000020,
comShareExclusive = 0x00000010
} EStgSharing;
typedef enum
{
comFailIfThere = 0x00000000,
comCreate = 0x00001000,
comConvert = 0x00020000,
comNoScratch = 0x00100000
} EStgAction;
typedef enum
{
comPriority = 0x00040000,
comDeleteOnRelease = 0x04000000
} EStgExtraFlags;
/* Auxiliary type to handle 64 bit longs */
typedef struct tagTLong64
{
long ValueLSB;
long ValueMSB;
} TLong64;
typedef struct tagTFileTime
{
long LowDateTime;
long HighDateTime;
} TFileTime;
typedef struct tagTGUID {
long Data1;
short Data2;
short Data3;
unsigned char Data4[8];
} TGUID;
typedef struct tagTStatSTG
{
long NamePtr;
EStorageTypes Type;
long SizeLSB;
long SizeMSB;
TFileTime ModifiedTime;
TFileTime CreatedTime;
TFileTime AccessedTime;
long CreationMode;
long LocksSupported;
TGUID ClassID;
long StateBits;
long Reserved;
} TStatSTG;
/////////////////////////////////////////////////////////
[
odl,
uuid(0000000c-0000-0000-C000-000000000046)
]
interface IStream : IUnknown
/////////////////////////////////////////////////////////
{
HRESULT Read(
[out] void *Buffer,
[in] long Count,
[out] long *ReadResult);
HRESULT Write(
[in] void *Buffer,
[in] long Count,
[out] long *WriteResult);
HRESULT Seek(
[in] long PositionLSB,
[in] long PositionMSB,
[in] ESeekOrigin Origin,
[out] TLong64 *SeekResult);
HRESULT SetSize(
[in] long NewSizeLSB,
[in] long NewSizeMSB);
HRESULT CopyTo(
[in] IStream *DestStream,
[in] long CountLSB,
[in] long CountMSB,
[out] TLong64 *ReadResult,
[out] TLong64 *WriteResult);
HRESULT Commit(
[in] ECommitFlags Flags);
HRESULT Revert();
HRESULT LockRegion(
[in] long OffsetLSB,
[in] long OffsetMSB,
[in] long CountLSB,
[in] long CountMSB,
[in] ELockType LockType);
HRESULT UnlockRegion(
[in] long OffsetLSB,
[in] long OffsetMSB,
[in] long CountLSB,
[in] long CountMSB,
[in] ELockType LockType);
HRESULT Stat(
[out] TStatSTG *StatSTG,
[in] EStatFlags Flags);
HRESULT Clone(
[out] IStream **NewStream);
};
/////////////////////////////////////////////////////////
[
odl,
uuid(0000000d-0000-0000-C000-000000000046)
]
interface IEnumSTATSTG : IUnknown
/////////////////////////////////////////////////////////
{
long Next(
[in] long Count,
[out] TStatSTG *Items,
[out] long *ItemsRetrieved);
long Skip(
[in] long Count);
HRESULT Reset();
HRESULT Clone(
[out] IEnumSTATSTG **Result);
};
/////////////////////////////////////////////////////////
[
odl,
uuid(0000000b-0000-0000-C000-000000000046)
]
interface IStorage : IUnknown
/////////////////////////////////////////////////////////
{
HRESULT CreateStream(
[in] BSTR Name,
[in] long Mode,
[in] long Reserved1,
[in] long Reserved2,
[out] IStream **NewStream);
HRESULT OpenStream(
[in] BSTR Name,
[in] long Reserved1,
[in] long Mode,
[in] long Reserved2,
[out] IStream **Result);
HRESULT CreateStorage(
[in] BSTR Name,
[in] long Mode,
[in] long Reserved1,
[in] long Reserved2,
[out] IStorage **Result);
HRESULT OpenStorage(
[in] BSTR Name,
[in] IStorage *PriorityStg,
[in] long Mode,
[in] long Reserved1,
[in] long Reserved2,
[out] IStorage **Result);
HRESULT CopyTo(
[in] long ExcludeCount,
[in] TGUID *ExcludeInterfaces,
[in] long ExcludeNamesPtr,
[in] IStorage *Destination);
HRESULT MoveElementTo(
[in] BSTR Name,
[in] IStorage *Destination,
[in] BSTR NewName,
[in] long Flags);
HRESULT Commit(
[in] ECommitFlags Flags);
HRESULT Revert();
HRESULT EnumElements(
[in] long Reserved1,
[in] long Reserved2,
[in] long Reserved3,
[out] IEnumSTATSTG **Result);
HRESULT DestroyElement(
[in] BSTR Name);
HRESULT RenameElement(
[in] BSTR OldName,
[in] BSTR NewName);
HRESULT SetElementTimes(
[in] BSTR Name,
[in] TFileTime *CreationTime,
[in] TFileTime *AccessedTime,
[in] TFileTime *ModificationTime);
HRESULT SetClass(
[in] TGUID* ClassID);
HRESULT SetStateBits(
[in] long StateBits,
[in] long Mask);
HRESULT Stat(
[out] TStatSTG *StatSTG,
[in] EStatFlags Flags);
};
/////////////////////////////////////////////////////////
[
dllname("ole32.dll"),
uuid(EB41CAC0-DD1B-11d4-8CF1-080039010D55),
helpstring("COM API functions")
]
module COMFunctions
/////////////////////////////////////////////////////////
{
[entry("StgIsStorageFile"),
helpstring("Checks to if the file is a Structured Storage file")]
long _stdcall AssertIsStorage(
[in] BSTR FileName);
[entry("StgCreateDocfile"),
helpstring("Creates a new compound file")]
HRESULT _stdcall StgCreateDocfile(
[in] BSTR FileName,
[in] long Mode,
[in] long Reserved,
[out] IStorage **Result);
[entry("StgOpenStorage"),
helpstring("Opens an existing compound file")]
HRESULT _stdcall StgOpenStorage(
[in] BSTR FileName,
[in] IStorage* PriorityStg,
[in] long Mode,
[in] long ExcludeNamesPtr,
[in] long Reserved,
[out] IStorage** Result);
[entry("StgSetTimes"),
helpstring("Sets the times associated with the specified file")]
HRESULT _stdcall StgSetTimes(
[in] BSTR FileName,
[in] TFileTime* CreationTime,
[in] TFileTime* AccessedTime,
[in] TFileTime* ModificationTime);
[entry("CoTaskMemFree"),
helpstring("Frees a memory address allocated by COM")]
void _stdcall CoTaskMemFree(
[in] long MemoryPtr);
};
/////////////////////////////////////////////////////////
[
dllname("oleaut32.dll"),
uuid(ECDB1C80-DD28-11d4-8CF1-080039010D55),
helpstring("Automation API functions")
]
module Automation
/////////////////////////////////////////////////////////
{
[entry("SysAllocString"),
helpstring("Creates a BSTR from a null delimited string")]
BSTR _stdcall SysAllocString(
[in] long StringPtr);
};
}
Working with IStorage properly would still be