//
// CXL_ARCH.CPP
//
// Source file for ArchiveLib 1.0
//
// Copyright (c) Greenleaf Software, Inc. 1994
// All Rights Reserved
//
// CONTENTS
//
// ALArchiveExtract()
// ALArchiveCreate()
// ALArchiveCreateFromArchive()
// ALArchiveAppend()
// ALArchiveAppendFromArchive()
// ALArchiveReadDirectory()
// ALArchiveWriteDirectory()
// ALArchiveDelete()
// ALArchiveSetComment()
// ALArchiveGetComment()
// ALArchiveGetCommentVB()
// ALArchiveGetStorage()
// ALArchiveFillListBoxWindow()
// ALArchiveFillListBoxDialog()
// deleteALArchive()
// ALArchiveSetError()
// ALArchiveGetStatusCode()
// ALArchiveGetStatusString()
// ALArchiveGetStatusStringVB()
// ALArchiveGetStatusDetail()
// ALArchiveGetStatusDetailVB()
// ALArchiveGetVersion()
//
// DESCRIPTION
//
// This file contains all the C translation layer routines for the
// member functions in ALArchiveBase. Note that we shorten the name
// of the base class to ALArchive here.
//
// Most of the descriptions in this file of the routines are going
// to be pretty skimpy. After all, there isn't much code to look
// at here anyway. For detailed descriptions, you will want to
// look in ARCHIVEB.CPP for the C++ archive base class member functions.
//
// The one thing all these functions do have in common is that they
// perform type checking on the arguments passed from C or VB.
//
// REVISION HISTORY
//
// May 22, 1994 2.0A : First release
//
//
#include "arclib.h"
#pragma hdrstop
#include "al.h"
#include "alcxl.h"
//
// extern "C" int ALArchiveExtract( hALArchive this_object,
// hALEntryList list )
//
// ARGUMENTS:
//
// this_object : The handle of (pointer to) an ALArchiveBase object.
//
// list : The handle of (pointer to) an ALEntryList object.
//
// RETURNS
//
// A status code, AL_SUCCESS or < AL_SUCCESS in case of an error.
//
// DESCRIPTION
//
// This is the wrapper function for ALArchiveBase::Extract(). See the
// function in ARCHIVEB.CPP for more details.
//
// REVISION HISTORY
//
// May 22, 1994 2.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveExtract( hALArchive this_object, hALEntryList list )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveExtract" );
AL_ASSERT_OBJECT( list, ALEntryList, "ALArchiveExtract" );
return ((ALArchiveBase *) this_object )->Extract( *( (ALEntryList *) list ) );
}
//
// extern "C" int ALArchiveCreate( hALArchive this_object,
// hALEntryList list )
//
// ARGUMENTS:
//
// this_object : The handle of (pointer to) an ALArchiveBase object.
//
// list : The handle of (pointer to) an ALEntryList object.
//
// RETURNS
//
// AL_SUCCESS for successful creation, < AL_SUCCESS for a failure.
//
// DESCRIPTION
//
// This is the C/VB wrapper function that supports the
// ALArchiveBase::Create(ALEntryList&) function. For details on the
// internals, see ARCHIVEB.CPP. Note that the two arguments
// are checked for correct type. The second version of
// ALArchiveBase::Create() is found below.
//
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveCreate( hALArchive this_object, hALEntryList list )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveCreate" );
AL_ASSERT_OBJECT( list, ALEntryList, "ALArchiveCreate" );
return ((ALArchiveBase *) this_object )->Create( *( (ALEntryList *) list ) );
}
//
// extern "C" int ALArchiveCreateFromArchive( hALArchive this_object,
// hALArchive input_archive,
// hALEntryList list )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// This is the archive that is going to be created.
//
// input_archive : A handle for (pointer to) an ALArchiveBase object.
// This is the archive that contains the compressed
// objects that are going to be inserted.
//
// list : A handle for (pointer to) an ALEntryList object.
// It will contains descriptions of all the compressed
// objects in input_archive that are going to be inserted
// into this_object.
//
// RETURNS
//
// AL_SUCCESS for successful creation, < AL_SUCCESS for a failure.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALArchiveBase::Create(ALArchiveBase&,ALEntrylist&).
// For details on how the member function actually works, take a
// gander at ARCHIVEB.CPP.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveCreateFromArchive( hALArchive this_object, hALArchive input_archive, hALEntryList list )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveCreateFromArchive" );
AL_ASSERT_OBJECT( input_archive, ALArchiveBase, "ALArchiveCreateFromArchive" );
AL_ASSERT_OBJECT( list, ALEntryList, "ALArchiveCreateFromArchive" );
return ((ALArchiveBase *) this_object )->Create( *(ALArchiveBase *)input_archive, *( (ALEntryList *) list ) );
}
//
// extern "C" int ALArchiveAppend( hALArchive this_object,
// hALEntryList list )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// This is the archive that is going to have new objects
// appended to it.
//
// list : A handle for (pointer to) an ALEntryList object.
// It will contains descriptions of all the standalone
// objects that are going to be inserted into this_object.
//
// RETURNS
//
// AL_SUCCESS for a successful append, < AL_SUCCESS for a failure.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALArchiveBase::Append(ALEntrylist&). For details on how the member
// function actually works, see ARCHIVEB.CPP.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveAppend( hALArchive this_object, hALEntryList list )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveAppend" );
AL_ASSERT_OBJECT( list, ALEntryList, "ALArchiveAppend" );
return ((ALArchiveBase *) this_object )->Append( *( (ALEntryList *) list ) );
}
//
// extern "C" int ALArchiveAppendFromArchive( hALArchive this_object,
// hALArchive input_archive,
// hALEntryList list )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// This is the archive that is going to get new stuff
// appended to it.
//
// input_archive : A handle for (pointer to) an ALArchiveBase object.
// This is the archive that contains the compressed
// objects that are going to be added to this_object.
//
// list : A handle for (pointer to) an ALEntryList object.
// It will contains descriptions of all the compressed
// objects in input_archive that are going to be added
// to this_object.
//
// RETURNS
//
// AL_SUCCESS for a successful append, < AL_SUCCESS for a failure.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALArchiveBase::Append(ALArchiveBase&,ALEntrylist&).
// For details on how the member function actually works, take a
// look at ARCHIVEB.CPP.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveAppendFromArchive( hALArchive this_object, hALArchive input_archive, hALEntryList list )
{
AL_ASSERT( ((ALArchiveBase *) this_object)->GoodTag(),
"archive argument is not a valid ALArchiveBase" );
AL_ASSERT( ((ALArchiveBase *) input_archive)->GoodTag(),
"input archive argument is not a valid ALArchiveBase" );
AL_ASSERT( ((ALEntryList *) list)->GoodTag(),
"list argument is not a valid ALEntryList" );
return ((ALArchiveBase *) this_object )->Append( *(ALArchiveBase *) input_archive, *( (ALEntryList *) list ) );
}
//
// extern "C" int ALArchiveReadDirectory( hALArchive this_object,
// hALEntryList list )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// This is the archive that is going to have its directory
// read into the list.
//
// list : A handle for (pointer to) an ALEntryList object.
// The list is going to receive descriptions for all
// of the compressed objects stored in the archive.
//
// RETURNS
//
// AL_SUCCESS for a successful read, < AL_SUCCESS for a failure.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALArchiveBase::ReadDirectory(ALEntrylist&). For details on how
// the member function actually works, take a look at ARCHIVEB.CPP.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveReadDirectory( hALArchive this_object, hALEntryList list )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveReadDirectory" );
AL_ASSERT_OBJECT( list, ALEntryList, "ALArchiveReadDirectory" );
return ((ALArchiveBase *) this_object )->ReadDirectory( *( (ALEntryList *) list ) );
}
//
// extern "C" int ALArchiveWriteDirectory( hALArchive this_object,
// hALEntryList list )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// This is the archive that is going to get the new copy
// of the directory written out to it.
//
// list : A handle for (pointer to) an ALEntryList object.
// The list contains descriptions for all
// of the compressed objects stored in the archive.
//
// RETURNS
//
// AL_SUCCESS for a successful write, < AL_SUCCESS for a failure.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALArchiveBase::WriteDirectory(ALEntrylist&). For details on how
// the member function actually works, take a look at ARCHIVEB.CPP.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveWriteDirectory( hALArchive this_object, hALEntryList list )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveWriteDirectory" );
AL_ASSERT_OBJECT( list, ALEntryList, "ALArchiveWriteDirectory" );
return ( (ALArchiveBase *) this_object )->WriteDirectory( *( (ALEntryList *) list ) );
}
//
// extern "C" int ALArchiveDelete( hALArchive this_object,
// hALEntryList list,
// hALArchive output_archive )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// This archive will have some of its compressed
// objects copied to the output archive. It will
// then be renamed to a backup name, with its contents
// unchanged.
//
// list : A handle for (pointer to) an ALEntryList object.
// All of the marked objects in the list will be
// deleted (by not copying) from the output_archive.
//
// output_archive: This archive will get some of the files from
// this_object. It will then be renamed to have the
// original name of this_object.
//
// RETURNS
//
// AL_SUCCESS for a successful deletion, < AL_SUCCESS for a failure.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALArchiveBase::Delete(). For details on how the member function
// actually works, take a look at ARCHIVEB.CPP.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveDelete( hALArchive this_object,
hALEntryList list,
hALArchive output_archive )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveDelete" );
AL_ASSERT_OBJECT( list, ALEntryList, "ALArchiveDelete" );
AL_ASSERT_OBJECT( output_archive, ALArchiveBase, "IALArchiveDelete" );
return ((ALArchiveBase *) this_object )->Delete( *( (ALEntryList *) list ), *( (ALArchiveBase *) output_archive ) );
}
//
// extern "C" int ALArchiveSetComment( hALArchive this_object,
// char *comment )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We are going to change the comment in archive, although
// the new comment won't be stored in the archive until
// we do a WriteDirectory().
//
// comment : An ASCII string that will be the new comment. Note
// that this gets passed properly from both C and VB.
// RETURNS
//
// AL_SUCCESS for a successful update, < AL_SUCCESS for a failure.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALArchiveBase::SetComment(). For details on how the member function
// actually works, take a look at ARCHIVEB.CPP.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveSetComment( hALArchive this_object, char *comment )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveSetComment" );
if ( comment == 0 )
comment = "";
return ( (ALArchiveBase *) this_object )->SetComment( comment );
}
//
// extern "C" char * ALArchiveGetComment( hALArchive this_object )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We are going to get the comment from this archive.
// Note that there won't be any comment here until
// you have performed a ReadDirectory().
// RETURNS
//
// A pointer to the new string, which is stored in the ArchiveBase
// object. You can print it, copy it, or whatever, but don't you
// dare change it.
//
// DESCRIPTION
//
// This is the C wrapper function for the C++ function
// ALArchiveBase::GetComment(). For details on how the member function
// actually works, take a look at ARCHIVEB.CPP. Very important
// to note that this is for C ONLY! VB strings take a special
// return type, see the next function.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" char * AL_FUNCTION ALArchiveGetComment( hALArchive this_object )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveGetComment" );
return (char *) ( (ALArchiveBase *) this_object )->GetComment();
}
//
// extern "C" long ALArchiveGetCommentVB( hALArchive this_object )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We are going to get the comment from this archive.
// Note that there won't be any comment here until
// you have performed a ReadDirectory().
// RETURNS
//
// A pointer (or something, I'm not really sure) to a VB string.
// The string is created inside VB.EXE (I think), by the
// special string creation function.
//
// DESCRIPTION
//
// This is the VB wrapper function for the C++ function
// ALArchiveBase::GetComment(). For details on how the member function
// actually works, take a look at ARCHIVEB.CPP. Very important
// to note that this is for VB ONLY! We have to do something
// special to translate a C character string to a VB native string
// type, and the two are not interchangeable!!!
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting. The return result from the
// function has to get ground through the VB string maker before we
// have something good to return.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
#if defined( AL_BUILDING_DLL ) && defined( AL_WINDOWS_GUI ) && !defined( AL_FLAT_MODEL )
extern "C" long AL_FUNCTION ALArchiveGetCommentVB( hALArchive this_object )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveGetCommentVB" );
const char _far *status = ( (ALArchiveBase *) this_object )->GetComment();
if ( status == 0 )
status = "";
return ALCreateVBString( status, (unsigned short int) _fstrlen( status ) );
}
#endif
//
// extern "C" hALStorage ALArchiveGetStorage( hALArchive hArchive )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// we are going to get the handle for (pointer to)
// the underlying storage object that contains the
// archive.
// RETURNS
//
// A handle for (pointer to) an ALStorage object. I think in theory
// it isn't possible for this guy to return a 0.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALArchiveBase::GetStorageObject(). For details on how the member
// function actually works, take a look at ARCHIVEB.CPP.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" hALStorage AL_FUNCTION ALArchiveGetStorage( hALArchive this_object )
{
AL_ASSERT( ((ALArchiveBase *) this_object)->GoodTag(),
"archive argument is not a valid ALArchiveBase" );
ALStorage *obj = ((ALArchiveBase *) this_object)->GetStorageObject();
return (hALStorage) obj;
}
//
// extern "C" int ALArchiveFillListBoxWindow( hALArchive this_object,
// HWND window )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We are going to fill a list box with the names
// of the storage objects in this archive.
//
// window : The window handle (not the ID!!!) of a list box.
//
// RETURNS
//
// AL_SUCCESS for good things, <AL_SUCCESS for bad things.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALArchiveBase::FillListBox(). For details on how the member
// function actually works, take a look at ARCHIVEB.CPP. Note that
// even though there is only a single C++ function, we have two
// different incarnations for the wrapper function. One that uses
// a window handle by itself, and another that uses a dialog handle
// /list box id combo to identify the list box.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
#if defined( AL_WINDOWS_GUI )
extern "C" int AL_FUNCTION ALArchiveFillListBoxWindow( hALArchive this_object,
HWND window )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveFillListBoxWindow" );
return ((ALArchiveBase *) this_object)->FillListBox( window );
}
//
// extern "C" int ALArchiveFillListBoxDialog( hALArchive this_object,
// HWND dialog,
// int id );
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We are going to fill a list box with the names
// of the storage objects in this archive.
//
// window : The window handle of a dialog box that contains
// the list box that will be filled.
//
// id : The id of the list box control in the dialog.
//
// RETURNS
//
// AL_SUCCESS for good things, <AL_SUCCESS for bad things.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALArchiveBase::FillListBox(). For details on how the member
// function actually works, take a look at ARCHIVEB.CPP. Note that
// even though there is only a single C++ function, we have two
// different incarnations for the wrapper function. One that uses
// a window handle by itself, and another that uses a dialog handle
// /list box id combo to identify the list box.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveFillListBoxDialog( hALArchive this_object,
HWND dialog,
int id )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveFillListBoxDialog" );
return ((ALArchiveBase *) this_object )->FillListBox( dialog, id );
}
#endif
//
// extern "C" void deleteALArchive( hALArchive this_object )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We destroy it in this function.
//
// RETURNS
//
// No returns from destructors.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALArchiveBase::~ALArchiveBase(). For details on how the member
// function actually works, take a look at ARCHIVEB.CPP.
//
// Note that this destructor function is virtual, and should be called
// to destroy any derived classes as well.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" void AL_FUNCTION deleteALArchive( hALArchive this_object )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "deleteALArchive()" );
delete (ALArchiveBase *) this_object;
}
//
// extern "C" int ALArchiveSetError( hALArchive this_object,
// int error,
// char *text )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We are going to set the archive's status member
// so that it is in an error state.
//
// error : The error code to apply to the object. Values from
// ALDEFS.H are good, but it really doesn't matter as
// long as you use a negative number.
//
// text : The text of the error message you want to associate with
// this error.
//
// RETURNS
//
// Returns the error code that you passed it.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ member function
// ALName::SetError(), as applied to an ALArchive object. For more
// details on how the function actually works, check out OBJNAME.CPP.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveSetError( hALArchive this_object,
int error,
char AL_DLL_FAR *text )
{
AL_ASSERT_OBJECT( this_object, ALArchive, "ALArchiveSetError" );
( (ALArchive *) this_object )->mStatus.SetError( error, text );
return error;
}
//
// extern "C" int ALArchiveGetStatusCode( hALArchive this_object )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
//
// RETURNS
//
// An integer that contains the current status code for the object.
// Note that values of < 0 always indicate an error conditions.
//
// DESCRIPTION
//
// This is the C/VB wrapper function for the C++ function
// ALName::GetStatusCode() as implemented for objects of type
// ALArchiveBase. For details on how the member
// function actually works, take a look at OBJNAME.CPP.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveGetStatusCode( hALArchive this_object )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase , "ALArchiveGetStatusCode" );
return ( (ALArchiveBase *) this_object )->mStatus.GetStatusCode();
}
//
// extern "C" char *ALArchiveGetStatusString( hALArchive this_object )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We want to get the string translation of the error
// code for this object.
//
// RETURNS
//
// Always returns a pointer to a short string translation of the
// current error code.
//
// DESCRIPTION
//
// This is the C wrapper function for the C++ function
// ALName::GetStatusString(), as implemented for class ALArchiveBase.
// Note that we need a completely different function return strings
// to VB programmers.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" char AL_DLL_FAR * AL_FUNCTION
ALArchiveGetStatusString( hALArchive this_object )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveGetStatusString" );
const char *status = ( (ALArchiveBase *) this_object )->mStatus.GetStatusString();
if ( status == 0 )
status = "";
return (char AL_DLL_FAR *) status;
}
//
// extern "C" long ALArchiveGetStatusStringVB( hALArchive this_object )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We want to get the string translation of the error
// code for this object.
//
// RETURNS
//
// Always returns a VB handle (pointer?) to a short string translation of
// the current error code for the ALArchiveBase object.
//
// DESCRIPTION
//
// This is the VB wrapper function for the C++ function
// ALName::GetStatusString(), as implemented for class ALArchiveBase.
// Note that we need a completely different function to return strings
// to C programmers. In this case, we use a special VB translation routine
// to convert a C string to one that is nice and easy for VB to use.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
#if defined( AL_BUILDING_DLL ) && defined( AL_WINDOWS_GUI ) && !defined( AL_FLAT_MODEL )
extern "C" long AL_FUNCTION ALArchiveGetStatusStringVB( hALArchive this_object )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveGetStatusStringVB" );
const char _far *status = ( (ALArchiveBase *) this_object )->mStatus.GetStatusString();
if ( status == 0 )
status = "";
return ALCreateVBString( status, (unsigned short int) _fstrlen( status ) );
}
#endif
//
// extern "C" char * ALArchiveGetStatusDetail( hALArchive this_object )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We want to get the detailed string describing this
// object's current status.
//
// RETURNS
//
// Always returns a pointer to a status detail message.
//
// DESCRIPTION
//
// This is the C wrapper function for the C++ function
// ALName::GetStatusDetail(), as implemented for class ALArchiveBase.
// Note that we need a completely different function to return strings
// to VB programmers.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" char AL_DLL_FAR * AL_FUNCTION
ALArchiveGetStatusDetail( hALArchive this_object )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveGetStatusDetail" );
const char *status = ( (ALArchiveBase *) this_object )->mStatus.GetStatusDetail();
if ( status == 0 )
status = "";
return (char AL_DLL_FAR *) status;
}
//
// extern "C" long ALArchiveGetStatusDetailVB( hALArchive this_object )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We want to get the detailed status message for
// this object.
//
// RETURNS
//
// Always returns a VB handle (pointer?) to a translation of
// the current status detail for the ALArchiveBase object.
//
// DESCRIPTION
//
// This is the VB wrapper function for the C++ function
// ALName::GetStatusDetail(), as implemented for class ALArchiveBase.
// Note that we need a completely different function to return strings
// to C programmers. In this case, we use a special VB translation routine
// to convert a C string to one that is nice and easy for VB to use.
//
// All that happens here is that the arguments are checked for correct
// type (when in debug mode), and a call is made to the appropriate
// member function, with lots of casting.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
#if defined( AL_BUILDING_DLL ) && defined( AL_WINDOWS_GUI ) && !defined( AL_FLAT_MODEL )
extern "C" long AL_FUNCTION ALArchiveGetStatusDetailVB( hALArchive archive )
{
AL_ASSERT_OBJECT( archive, ALArchiveBase, "ALArchiveGetStatusDetailVB" );
const char _far *status = ( (ALArchiveBase *) archive)->mStatus.GetStatusDetail();
if ( status == 0 )
status = "";
return ALCreateVBString( status, (unsigned short int) _fstrlen( status ) );
}
#endif
//
// extern "C" int ALArchiveGetVersion( hALArchive this_object )
//
// ARGUMENTS:
//
// this_object : A handle for (pointer to) an ALArchiveBase object.
// We want to get the version of this archive.
//
// RETURNS
//
// Always returns the integer version of the object. The current version
// is 0x100. Note that this is the version of the Archive, not of the
// library.
//
// DESCRIPTION
//
// This is the VB/C wrapper function for the C++ function
// ALArchiveBase::GetVersion(). For details on this function,
// take a look at source file ARCHIVEB.CPP.
//
// REVISION HISTORY
//
// May 24, 1994 1.0A : First release
//
extern "C" int AL_FUNCTION ALArchiveGetVersion( hALArchive this_object )
{
AL_ASSERT_OBJECT( this_object, ALArchiveBase, "ALArchiveGetVersion" );
return ( (ALArchiveBase *) this_object )->GetVersion();
}