TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-04-26 14:55:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
Torque3D/Engine/lib/lmng/contrib/bcb/mngdump/CHUNKS.CPP
DavidWyand-GG 7dbfe6994d Engine directory for ticket #1
2012-09-19 11:15:01 -04:00

1689 lines
54 KiB
C++
Raw Blame History

//
// Chunks.cpp
//
// The following functions are to assemble a string for each chunk
// The function name "Info_????" denote which chunk it handles
//
// Comments marked @todo@ may, or maynot, be filled in at a later date !
//
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Main.h"
# define xUSE_UNKNOWN // remove "x" to report of "UNKNOWN" - else ""
# define FFACTOR ((float)100000.0)
// NB We must use Octal for RichEdit's newlines - MicroSoft love Octal !
# define nl "\015\012"
# define TAB asTab
// Ps : If anyone reading this knows how to do this using token
// pasting please let me know ! (AP)
// ConCat newline to string
# define NL as = as + nl
// Integer ARGuement
# define IARG( _str_, _int_ )\
as = as + TAB + (_str_) + " " + String( _int_ )
// Bool ARGuement
# define BARG( _str_, _bool_ )\
if( WantsBool() )\
as = as + TAB + (_str_) + " " + ((_bool_) ? "true" : "false");\
else\
as = as + TAB + (_str_) + " " + IntToStr( _bool_ );
// Float ARGuement
# define FARG( _str_, _float_ )\
as = as + TAB + (_str_) + " " + String( _float_ )
// szText ARGuement
# define ZARG( _str_, _sz_ )\
as = as + TAB + (_str_) + " \"" + String( _sz_ ) + "\""
// Concat general strings
# define STR( _str_ ) as = as + _str_
// Concat Hex string
# define HEXSTR( _str_ ) as = as + IntToHex(_str_,2)
// Concat Macro Identifier to ARG
#define MI( _str_ ) as = as + TAB + _str_;
// Concat "(" Comment ")" to ARG
#define PCOM( _str_ )\
if( WantsComments() ) as = as + TAB + "(" + _str_ + ")";
// Concat "float(" Comment ")" to ARG
#define FPCOM( _str_ )\
if( WantsComments() ) as = as + TAB + "float(" + _str_ + ")";
//---------------------------------------------------------------------------
// Macro Identifiers - these, below, are used several times
// NB those used once have local #define's and #undef's
//---------------------------------------------------------------------------
# ifdef USE_UNKNOWN
# define UNKNOWN "UNKNOWN"
# else
# define UNKNOWN ""
# endif
// Does this need two to be more visible ?
# define ILLEGAL_VALUE ">> ILLEGAL VALUE << "
// IHDR, BASI, JHDR, PROM, sPLT
# define MI_BITDEPTH( _i_ )\
if( WantsMacroIds() )\
switch( (_i_) ) {\
case MNG_BITDEPTH_1 : MI( "MNG_BITDEPTH_1" ); break;\
case MNG_BITDEPTH_2 : MI( "MNG_BITDEPTH_2" ); break;\
case MNG_BITDEPTH_4 : MI( "MNG_BITDEPTH_4" ); break;\
case MNG_BITDEPTH_8 : MI( "MNG_BITDEPTH_8" ); break;\
case MNG_BITDEPTH_16 : MI( "MNG_BITDEPTH_16" ); break;\
default : MI(ILLEGAL_VALUE);\
}
// IHDR, BASI, PROM
# define MI_COLORTYPE( _i_ )\
if( WantsMacroIds() )\
switch( (_i_) ) {\
case MNG_COLORTYPE_GRAY : MI( "MNG_COLORTYPE_GRAY" ); break;\
case MNG_COLORTYPE_RGB : MI( "MNG_COLORTYPE_RGB" ); break;\
case MNG_COLORTYPE_INDEXED : MI( "MNG_COLORTYPE_INDEXED" ); break;\
case MNG_COLORTYPE_GRAYA : MI( "MNG_COLORTYPE_GRAYA" ); break;\
case MNG_COLORTYPE_RGBA : MI( "MNG_COLORTYPE_RGBA" ); break;\
default : MI(ILLEGAL_VALUE);\
}
// IHDR, zTXt, iTXt, iCCP, BASI, JHDR
# define MI_COMPRESSION_DEFLATE( _i_ )\
if( WantsMacroIds() ) {\
if( (_i_) == MNG_COMPRESSION_DEFLATE ) {\
MI( "MNG_COMPRESSION_DEFLATE" );\
} else {\
MI( ILLEGAL_VALUE );\
}\
}
// IHDR, BASI, JHDR
# define MI_FILTER( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_FILTER_ADAPTIVE : MI( "MNG_FILTER_ADAPTIVE" ); break;\
case MNG_FILTER_NO_ADAPTIVE : MI( "MNG_FILTER_NO_ADAPTIVE" ); break;\
case MNG_FILTER_DIFFERING : MI( "MNG_FILTER_DIFFERING" ); break;\
case MNG_FILTER_MASK : MI( "MNG_FILTER_MASK" ); break;\
default : MI(UNKNOWN);\
}
//NB MNG_FILTER_NO_DIFFERING == MNG_FILTER_ADAPTIVE
// IHDR, BASI, JHDR
#define MI_INTERLACE( _i_ )\
if( WantsMacroIds() ) {\
if( (_i_) == MNG_INTERLACE_NONE ) {\
MI( "MNG_INTERLACE_NONE" )\
} else if( (_i_) == MNG_INTERLACE_ADAM7 ) {\
MI( "MNG_INTERLACE_ADAM7" );\
} else { MI(ILLEGAL_VALUE);} \
}
// pHYs, pHYg
#define MI_UNITS( _i_ )\
if( WantsMacroIds() ) {\
if( (_i_) == MNG_UNIT_UNKNOWN ) {\
MI( "MNG_UNIT_UNKNOWN" )\
} else if( (_i_) == MNG_UNIT_METER ) {\
MI( "MNG_UNIT_METER" );\
} else { MI(UNKNOWN);} \
}
// CLON & MOVE
#define MI_LOCATION( _i_ )\
if( WantsMacroIds() ) {\
if( (_i_) == MNG_LOCATION_ABSOLUTE ) {\
MI( "MNG_LOCATION_ABSOLUTE" )\
} else if( (_i_) == MNG_LOCATION_RELATIVE ) {\
MI( "MNG_LOCATION_RELATIVE" );\
} else { MI(ILLEGAL_VALUE);} \
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_BACK( mng_handle hMNG, mng_handle hChunk, String &as )
{
// NB for BACKGROUND other values are only advisory
#define MI_BACKGROUND( _i_ )\
if( WantsMacroIds() ) {\
if( (_i_) == MNG_BACKGROUNDCOLOR_MANDATORY ) {\
MI( "MNG_BACKGROUNDCOLOR_MANDATORY" )\
} else if( (_i_) == MNG_BACKGROUNDIMAGE_MANDATORY ) {\
MI( "MNG_BACKGROUNDIMAGE_MANDATORY" );\
} \
}
# define MI_BACKGROUND_TILE( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_BACKGROUNDIMAGE_NOTILE : MI( "MNG_BACKGROUNDIMAGE_NOTILE" ); break;\
case MNG_BACKGROUNDIMAGE_TILE : MI( "MNG_BACKGROUNDIMAGE_TILE" ); break;\
default : MI(UNKNOWN);\
}
mng_uint16 iRed;
mng_uint16 iGreen;
mng_uint16 iBlue;
mng_uint8 iMandatory;
mng_uint16 iImageid;
mng_uint8 iTile;
if( mng_getchunk_back( hMNG, hChunk,
&iRed, &iGreen, &iBlue,
&iMandatory, &iImageid, &iTile ) != 0 )
return false;
IARG( "iRed", iRed );
NL; IARG( "iGreen",iGreen );
NL; IARG( "iBlue", iBlue );
NL; IARG( "iMandatory", iMandatory ); MI_BACKGROUND( iMandatory );
NL; IARG( "iImageid", iImageid );
NL; IARG( "iTile", iTile ); MI_BACKGROUND_TILE( iTile );
return true;
# undef MI_BACKGROUND
# undef MI_BACKGROUND_TILE
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_BASI( mng_handle hMNG, mng_handle hChunk, String &as )
{
#define MI_VIEWABLE( _i_ )\
if( WantsMacroIds() ) {\
if( (_i_) == MNG_NOTVIEWABLE ) {\
MI( "MNG_NOTVIEWABLE" )\
} else if( (_i_) == MNG_VIEWABLE ) {\
MI( "MNG_VIEWABLE" );\
} else { MI(UNKNOWN);} \
}
mng_uint32 iWidth;
mng_uint32 iHeight;
mng_uint8 iBitdepth;
mng_uint8 iColortype;
mng_uint8 iCompression;
mng_uint8 iFilter;
mng_uint8 iInterlace;
mng_uint16 iRed;
mng_uint16 iGreen;
mng_uint16 iBlue;
mng_uint16 iAlpha;
mng_uint8 iViewable;
if( mng_getchunk_basi( hMNG, hChunk,
&iWidth, &iHeight, &iBitdepth, &iColortype,
&iCompression, &iFilter, &iInterlace,
&iRed, &iGreen, &iBlue, &iAlpha,
&iViewable ) != 0 )
return false;
IARG( "iWidth", iWidth );
NL; IARG( "iHeight", iHeight );
NL; IARG( "iBitdepth", iBitdepth ); MI_BITDEPTH( iBitdepth );
NL; IARG( "iColortype", iColortype ); MI_COLORTYPE( iColortype );
NL; IARG( "iCompression", iCompression ); MI_COMPRESSION_DEFLATE( iCompression );
NL; IARG( "iFilter", iFilter ); MI_FILTER( iFilter );
NL; IARG( "iInterlace", iInterlace ); MI_INTERLACE( iInterlace );
NL; IARG( "iRed", iRed );
NL; IARG( "iGreen", iGreen );
NL; IARG( "iBlue", iBlue );
NL; IARG( "iAlpha", iAlpha );
NL; IARG( "iViewable", iViewable ); MI_VIEWABLE( iViewable );
return true;
# undef MI_VIEWABLE
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_CLIP( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_CLIPPING( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_CLIPPING_ABSOLUTE : MI( "MNG_CLIPPING_ABSOLUTE" ); break;\
case MNG_CLIPPING_RELATIVE : MI( "MNG_CLIPPING_RELATIVE" ); break;\
default : MI(UNKNOWN);\
}
mng_uint16 iFirstid;
mng_uint16 iLastid;
mng_uint8 iCliptype;
mng_int32 iClipl;
mng_int32 iClipr;
mng_int32 iClipt;
mng_int32 iClipb;
if( mng_getchunk_clip( hMNG, hChunk,
&iFirstid, &iLastid,
&iCliptype, &iClipl, &iClipr, &iClipt, &iClipb ) != 0 )
return false;
IARG( "iFirstid", iFirstid );
NL; IARG( "iLastid", iLastid );
NL; IARG( "iCliptype", iCliptype ); MI_CLIPPING( iCliptype );
NL; IARG( "iClipl", iClipl );
NL; IARG( "iClipr", iClipr );
NL; IARG( "iClipt", iClipt );
NL; IARG( "iClipb", iClipb );
return true;
# undef MI_CLIPPING
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_CLON( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_CLONTYPE( _i_ )\
if( WantsMacroIds() )\
switch( (_i_) ) {\
case MNG_FULL_CLONE : MI( "MNG_FULL_CLONE" ); break;\
case MNG_PARTIAL_CLONE : MI( "MNG_PARTIAL_CLONE" ); break;\
case MNG_RENUMBER : MI( "MNG_RENUMBER" ); break;\
default : MI(UNKNOWN);\
}
#define MI_CLON_CONCRETE( _i_ )\
if( WantsMacroIds() ) {\
if( (_i_) == MNG_CONCRETE_ASPARENT ) {\
MI( "MNG_CONCRETE_ASPARENT" )\
} else if( (_i_) == MNG_CONCRETE_MAKEABSTRACT ) {\
MI( "MNG_CONCRETE_MAKEABSTRACT" );\
} else { MI(UNKNOWN);} \
}
mng_uint16 iSourceid;
mng_uint16 iCloneid;
mng_uint8 iClonetype;
mng_uint8 iDonotshow;
mng_uint8 iConcrete;
mng_bool bHasloca;
mng_uint8 iLocationtype;
mng_int32 iLocationx;
mng_int32 iLocationy;
if( mng_getchunk_clon( hMNG, hChunk,
&iSourceid, &iCloneid, &iClonetype, &iDonotshow,
&iConcrete, &bHasloca,
&iLocationtype, &iLocationx, &iLocationy ) != 0 )
return false;
IARG( "iSourceid", iSourceid );
NL; IARG( "iCloneid", iCloneid );
NL; IARG( "iClonetype", iClonetype ); MI_CLONTYPE( iClonetype );
NL; IARG( "iDonotshow", iDonotshow );
NL; IARG( "iConcrete", iConcrete ); MI_CLON_CONCRETE( iConcrete );
NL; BARG( "bHasloca", bHasloca );
NL; IARG( "iLocationtype", iLocationtype ); MI_LOCATION( iLocationtype );
NL; IARG( "iLocationx", iLocationx );
NL; IARG( "iLocationy", iLocationy );
return true;
# undef MI_CLONTYPE
# undef MI_CLON_CONCRETE
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_DBYK( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_POLARITY( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_POLARITY_ONLY : MI( "MNG_POLARITY_ONLY" ); break;\
case MNG_POLARITY_ALLBUT : MI( "MNG_POLARITY_ALLBUT" ); break;\
default : MI(UNKNOWN);\
}
mng_chunkid iChunkname;
mng_uint8 iPolarity;
mng_uint32 iKeywordssize;
mng_pchar zKeywords;
if( mng_getchunk_dbyk( hMNG, hChunk,
&iChunkname, &iPolarity, &iKeywordssize, &zKeywords ) != 0 )
return false;
IARG( "iChunkname", iChunkname ); // show chunk name ? @todo@
NL; IARG( "iPolarity", iPolarity ); MI_POLARITY( iPolarity );
NL; IARG( "iKeywordssize", iKeywordssize );
NL; ZARG( "zKeywords", zKeywords );
return true;
# undef MI_POLARITY
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_DEFI( mng_handle hMNG, mng_handle hChunk, String &as )
{
#define MI_DONOTSHOW( _i_ )\
if( WantsMacroIds() ) {\
if( (_i_) == MNG_DONOTSHOW_VISIBLE ) {\
MI( "MNG_DONOTSHOW_VISIBLE" )\
} else if( (_i_) == MNG_DONOTSHOW_NOTVISIBLE ) {\
MI( "MNG_DONOTSHOW_NOTVISIBLE" );\
}\
}
#define MI_DEFI_CONCRETE( _i_ )\
if( WantsMacroIds() ) {\
if( (_i_) == MNG_ABSTRACT ) {\
MI( "MNG_ABSTRACT" )\
} else if( (_i_) == MNG_CONCRETE ) {\
MI( "MNG_CONCRETE" );\
}\
}
mng_uint16 iObjectid;
mng_uint8 iDonotshow;
mng_uint8 iConcrete;
mng_bool bHasloca;
mng_int32 iXlocation;
mng_int32 iYlocation;
mng_bool bHasclip;
mng_int32 iLeftcb;
mng_int32 iRightcb;
mng_int32 iTopcb;
mng_int32 iBottomcb;
if( mng_getchunk_defi( hMNG, hChunk,
&iObjectid, &iDonotshow, &iConcrete,
&bHasloca, &iXlocation, &iYlocation,
&bHasclip, &iLeftcb, &iRightcb, &iTopcb, &iBottomcb ) != 0 )
return false;
IARG( "iObjectid", iObjectid );
NL; IARG( "iDonotshow", iDonotshow ); MI_DONOTSHOW( iDonotshow );
NL; IARG( "iConcrete", iConcrete ); MI_DEFI_CONCRETE( iConcrete );
NL; BARG( "bHasloca", bHasloca );
NL; IARG( "iXlocation", iXlocation );
NL; IARG( "iYlocation", iYlocation );
NL; BARG( "bHasclip", bHasclip );
NL; IARG( "iLeftcb", iLeftcb );
NL; IARG( "iRightcb", iRightcb );
NL; IARG( "iTopcb", iTopcb );
NL; IARG( "iBottomcb", iBottomcb );
return true;
# undef MI_DONOTSHOW
# undef MI_DEFI_CONCRETE
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_DHDR( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_IMAGETYPE( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_IMAGETYPE_UNKNOWN : MI( "MNG_IMAGETYPE_UNKNOWN" ); break;\
case MNG_IMAGETYPE_PNG : MI( "MNG_IMAGETYPE_PNG" ); break;\
case MNG_IMAGETYPE_JNG : MI( "MNG_IMAGETYPE_JNG" ); break;\
default : MI(UNKNOWN);\
}
# define MI_DELTATYPE( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_DELTATYPE_REPLACE : MI( "MNG_DELTATYPE_REPLACE" ); break;\
case MNG_DELTATYPE_BLOCKPIXELADD : MI( "MNG_DELTATYPE_BLOCKPIXELADD" ); break;\
case MNG_DELTATYPE_BLOCKALPHAADD : MI( "MNG_DELTATYPE_BLOCKALPHAADD" ); break;\
case MNG_DELTATYPE_BLOCKCOLORADD : MI( "MNG_DELTATYPE_BLOCKCOLORADD" ); break;\
case MNG_DELTATYPE_BLOCKPIXELREPLACE : MI( "MNG_DELTATYPE_BLOCKPIXELREPLACE" ); break;\
case MNG_DELTATYPE_BLOCKALPHAREPLACE : MI( "MNG_DELTATYPE_BLOCKALPHAREPLACE" ); break;\
case MNG_DELTATYPE_BLOCKCOLORREPLACE : MI( "MNG_DELTATYPE_BLOCKCOLORREPLACE" ); break;\
case MNG_DELTATYPE_NOCHANGE : MI( "MNG_DELTATYPE_NOCHANGE" ); break;\
default : MI(UNKNOWN);\
}
mng_uint16 iObjectid;
mng_uint8 iImagetype;
mng_uint8 iDeltatype;
mng_uint32 iBlockwidth;
mng_uint32 iBlockheight;
mng_uint32 iBlockx;
mng_uint32 iBlocky;
if( mng_getchunk_dhdr( hMNG, hChunk,
&iObjectid, &iImagetype, &iDeltatype,
&iBlockwidth, &iBlockheight, &iBlockx, &iBlocky ) != 0 )
return false;
IARG( "iObjectid", iObjectid );
NL; IARG( "iImagetype", iImagetype ); MI_IMAGETYPE( iImagetype );
NL; IARG( "iDeltatype", iDeltatype ); MI_DELTATYPE( iDeltatype );
NL; IARG( "iBlockwidth", iBlockwidth );
NL; IARG( "iBlockheight", iBlockheight );
NL; IARG( "iBlockx", iBlockx );
NL; IARG( "iBlocky", iBlocky );
return true;
# undef MI_IMAGETYPE
# undef MI_DELTATYPE
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_DISC( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iCount;
mng_uint16p pObjectids;
if( mng_getchunk_disc( hMNG, hChunk, &iCount, &pObjectids ) != 0 )
return false;
IARG( "iCount", iCount );
//pObjectids pObjectids
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_DROP( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iCount;
mng_chunkidp pChunknames;
if( mng_getchunk_drop( hMNG, hChunk, &iCount, &pChunknames ) != 0 )
return false;
IARG( "iCount", iCount );
// pChunknamesp Chunknames // Iterate chunk names ? @todo@
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_ENDL( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint8 iLevel;
if( mng_getchunk_endl( hMNG, hChunk, &iLevel ) != 0 )
return false;
IARG( "iLevel", iLevel );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_FRAM( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_BOUNDARY( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_BOUNDARY_ABSOLUTE : MI( "MNG_BOUNDARY_ABSOLUTE" ); break;\
case MNG_BOUNDARY_RELATIVE : MI( "MNG_BOUNDARY_RELATIVE" ); break;\
default : MI(UNKNOWN);\
}
# define MI_FRAMINGMODE( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_FRAMINGMODE_NOCHANGE : MI( "MNG_FRAMINGMODE_NOCHANGE" ); break;\
case MNG_FRAMINGMODE_1 : MI( "MNG_FRAMINGMODE_1" ); break;\
case MNG_FRAMINGMODE_2 : MI( "MNG_FRAMINGMODE_2" ); break;\
case MNG_FRAMINGMODE_3 : MI( "MNG_FRAMINGMODE_3" ); break;\
case MNG_FRAMINGMODE_4 : MI( "MNG_FRAMINGMODE_4" ); break;\
default : MI(UNKNOWN);\
}
# define MI_CHANGEDELAY( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_CHANGEDELAY_NO : MI( "MNG_CHANGEDELAY_NO" ); break;\
case MNG_CHANGEDELAY_NEXTSUBFRAME : MI( "MNG_CHANGEDELAY_NEXTSUBFRAME" ); break;\
case MNG_CHANGEDELAY_DEFAULT : MI( "MNG_CHANGEDELAY_DEFAULT" ); break;\
default : MI(UNKNOWN);\
}
# define MI_CHANGETIMOUT( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_CHANGETIMOUT_NO : MI( "MNG_CHANGETIMOUT_NO" ); break;\
case MNG_CHANGETIMOUT_DETERMINISTIC_1 : MI( "MNG_CHANGETIMOUT_DETERMINISTIC_1" ); break;\
case MNG_CHANGETIMOUT_DETERMINISTIC_2 : MI( "MNG_CHANGETIMOUT_DETERMINISTIC_2" ); break;\
case MNG_CHANGETIMOUT_DECODER_1 : MI( "MNG_CHANGETIMOUT_DECODER_1" ); break;\
case MNG_CHANGETIMOUT_DECODER_2 : MI( "MNG_CHANGETIMOUT_DECODER_2" ); break;\
case MNG_CHANGETIMOUT_USER_1 : MI( "MNG_CHANGETIMOUT_USER_1" ); break;\
case MNG_CHANGETIMOUT_USER_2 : MI( "MNG_CHANGETIMOUT_USER_2" ); break;\
case MNG_CHANGETIMOUT_EXTERNAL_1 : MI( "MNG_CHANGETIMOUT_EXTERNAL_1" ); break;\
case MNG_CHANGETIMOUT_EXTERNAL_2 : MI( " MNG_CHANGETIMOUT_EXTERNAL_2" ); break;\
default : MI(UNKNOWN);\
}
# define MI_CHANGECLIPPING( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_CHANGECLIPPING_NO : MI( "MNG_CHANGECLIPPING_NO" ); break;\
case MNG_CHANGECLIPPING_NEXTSUBFRAME : MI( "MNG_CHANGECLIPPING_NEXTSUBFRAME" ); break;\
case MNG_CHANGECLIPPING_DEFAULT : MI( "MNG_CHANGECLIPPING_DEFAULT" ); break;\
default : MI(UNKNOWN);\
}
# define MI_CHANGESYNCID( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_CHANGESYNCID_NO : MI( "MNG_CHANGESYNCID_NO" ); break;\
case MNG_CHANGESYNCID_NEXTSUBFRAME : MI( "MNG_CHANGESYNCID_NEXTSUBFRAME" ); break;\
case MNG_CHANGESYNCID_DEFAULT : MI( "MNG_CHANGESYNCID_DEFAULT" ); break;\
default : MI(UNKNOWN);\
}
mng_bool bEmpty;
mng_uint8 iMode;
mng_uint32 iNamesize;
mng_pchar zName;
mng_uint8 iChangedelay;
mng_uint8 iChangetimeout;
mng_uint8 iChangeclipping;
mng_uint8 iChangesyncid;
mng_uint32 iDelay;
mng_uint32 iTimeout;
mng_uint8 iBoundarytype;
mng_int32 iBoundaryl;
mng_int32 iBoundaryr;
mng_int32 iBoundaryt;
mng_int32 iBoundaryb;
mng_uint32 iCount;
mng_uint32p pSyncids;
if( mng_getchunk_fram( hMNG, hChunk,
&bEmpty, &iMode, &iNamesize, &zName,
&iChangedelay, &iChangetimeout, &iChangeclipping, &iChangesyncid,
&iDelay, &iTimeout,
&iBoundarytype, &iBoundaryl, &iBoundaryr,&iBoundaryt, &iBoundaryb,
&iCount, &pSyncids ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; IARG( "iMode", iMode ); MI_FRAMINGMODE( iMode );
NL; IARG( "iNamesize", iNamesize );
NL; ZARG( "zName", zName );
NL; IARG( "iChangedelay", iChangedelay ); MI_CHANGEDELAY( iChangedelay );
NL; IARG( "iChangetimeout", iChangetimeout ); MI_CHANGETIMOUT( iChangetimeout );
NL; IARG( "iChangeclipping", iChangeclipping ); MI_CHANGECLIPPING( iChangeclipping );
NL; IARG( "iChangesyncid", iChangesyncid ); MI_CHANGESYNCID( iChangesyncid );
NL; IARG( "iDelay", iDelay );
NL; IARG( "iTimeout", iTimeout );
NL; IARG( "iBoundarytype", iBoundarytype ); MI_BOUNDARY( iBoundarytype );
NL; IARG( "iBoundaryl", iBoundaryl );
NL; IARG( "iBoundaryr", iBoundaryr );
NL; IARG( "iBoundaryt", iBoundaryt );
NL; IARG( "iBoundaryb", iBoundaryb );
NL; IARG( "iCount", iCount );
//pSyncids pSyncids @todo@
return true;
# undef MI_BOUNDARY
# undef MI_FRAMINGMODE
# undef MI_CHANGEDELAY
# undef MI_CHANGETIMOUT
# undef MI_CHANGECLIPPING
# undef MI_CHANGESYNCID
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_IDAT( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iRawlen;
mng_ptr pRawdata;
if( mng_getchunk_idat( hMNG, hChunk, &iRawlen, &pRawdata ) != 0 )
return false;
IARG( "iRawlen", iRawlen );
if( WantsRawData() ) {
Byte *bp = (Byte*)pRawdata;
NL; STR( TAB + "Rawdata : " );
// show the first 16 bytes, as hex
for( int n = 0; n < 16; n +=1 )
HEXSTR( (int)bp[n] ) + " ";
}
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_IEND( mng_handle hMNG, mng_handle hChunk, String &as )
{
NL + TAB; STR( "End of Image." );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_IHDR(
mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iWidth;
mng_uint32 iHeight;
mng_uint8 iBitdepth;
mng_uint8 iColortype;
mng_uint8 iCompression;
mng_uint8 iFilter;
mng_uint8 iInterlace;
if( mng_getchunk_ihdr( hMNG, hChunk, &iWidth, &iHeight, &iBitdepth,
&iColortype, &iCompression, &iFilter, &iInterlace ) != 0 )
return false;
IARG( "iWidth", iWidth );
NL; IARG( "iHeight", iHeight );
NL; IARG( "iBitdepth", iBitdepth ); MI_BITDEPTH( iBitdepth );
NL; IARG( "iColortype", iColortype ); MI_COLORTYPE( iColortype );
NL; IARG( "iCompression", iCompression ); MI_COMPRESSION_DEFLATE( iCompression );
NL; IARG( "iFilter", iFilter ); MI_FILTER( iFilter );
NL; IARG( "iInterlace", iInterlace ); MI_INTERLACE( iInterlace );
if( WantsComments() )
{
NL; NL + TAB;
switch( iColortype ) {
case MNG_COLORTYPE_GRAY :
switch( iBitdepth ) {
case 1 : case 2 : case 4 : case 8 : case 16 :
STR( "Each pixel value is a greyscale level -" );
} // inner switch
break;
case MNG_COLORTYPE_RGB :
switch( iBitdepth ) {
case 8 : case 16 :
STR( "Each pixel value is an R,G,B series -" );
} // inner switch
break;
case MNG_COLORTYPE_INDEXED :
switch( iBitdepth ) {
case 1 : case 2 : case 4 : case 8 :
STR( "Each pixel value is a palette index -" );
} // inner switch
break;
case MNG_COLORTYPE_GRAYA :
switch( iBitdepth ) {
case 8 : case 16 :
STR( "Each pixel value is a greyscale level, "\
"followed by an Alpha channel level -" );
} // inner switch
break;
case MNG_COLORTYPE_RGBA :
switch( iBitdepth ){
case 8 : case 16:
STR( "Each pixel value is an R,G,B "\
"series, followed by an Alpha channel level -" );
} // inner switch
break;
}
STR( " " + String(iBitdepth) + " bits per pixel." );
}
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_JDAT( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iRawlen;
mng_ptr pRawdata = NULL;
if( mng_getchunk_jdat( hMNG, hChunk, &iRawlen, &pRawdata ) != 0 )
return false;
IARG( "iRawlen", iRawlen );
if( WantsRawData() ) {
Byte *bp = (Byte*)pRawdata;
NL; STR( TAB + "Rawdata : " );
// show the first 16 bytes, as hex
for( int n = 0; n < 16; n +=1 )
HEXSTR( (int)bp[n] ) + " ";
}
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_JHDR( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_JPEG_COLORTYPE( _i_ )\
if( WantsMacroIds() ) {\
switch( _i_ ){\
case MNG_COLORTYPE_JPEGGRAY : MI( "MNG_COLORTYPE_JPEGGRAY");break;\
case MNG_COLORTYPE_JPEGCOLOR : MI( "MNG_COLORTYPE_JPEGCOLOR");break;\
case MNG_COLORTYPE_JPEGGRAYA : MI( "MNG_COLORTYPE_JPEGGRAYA");break;\
case MNG_COLORTYPE_JPEGCOLORA : MI( "MNG_COLORTYPE_JPEGCOLORA");break;\
default : MI(UNKNOWN);\
}\
}
# define MI_JPEG_BITDEPTH( _i_ )\
if( WantsMacroIds() ) {\
switch( _i_ ){\
case MNG_BITDEPTH_JPEG8 : MI("MNG_BITDEPTH_JPEG8");break;\
case MNG_BITDEPTH_JPEG12 : MI("MNG_BITDEPTH_JPEG12");break;\
case MNG_BITDEPTH_JPEG8AND12 : MI("MNG_BITDEPTH_JPEG8AND12");break;\
default : MI(UNKNOWN);\
}\
}
# define MI_JPEGCOMPRESSION( _i_ )\
if( WantsMacroIds() ) {\
if( iImagecompression == MNG_COMPRESSION_BASELINEJPEG ) {\
MI( "MNG_COMPRESSION_BASELINEJPEG" );\
} else { MI(ILLEGAL_VALUE); };\
}
# define MI_JPEGINTERLACE( _i_ )\
if( WantsMacroIds() ) {\
if( iImageinterlace == MNG_INTERLACE_SEQUENTIAL ) {\
MI( "MNG_INTERLACE_SEQUENTIAL");\
} else {\
MI( "MNG_INTERLACE_PROGRESSIVE" );\
}\
}
// NB alpha bitdepth is not png bitdepth because it can be 0 (zero)
# define MI_ALPHABITDEPTH( _i_ )\
if( WantsMacroIds() )\
switch( (_i_) ) {\
case MNG_BITDEPTH_1 : MI( "MNG_BITDEPTH_1" ); break;\
case MNG_BITDEPTH_2 : MI( "MNG_BITDEPTH_2" ); break;\
case MNG_BITDEPTH_4 : MI( "MNG_BITDEPTH_4" ); break;\
case MNG_BITDEPTH_8 : MI( "MNG_BITDEPTH_8" ); break;\
case MNG_BITDEPTH_16 : MI( "MNG_BITDEPTH_16" ); break;\
case 0 : break;\
default : MI(ILLEGAL_VALUE);\
}
mng_uint32 iWidth;
mng_uint32 iHeight;
mng_uint8 iColortype;
mng_uint8 iImagesampledepth;
mng_uint8 iImagecompression;
mng_uint8 iImageinterlace;
mng_uint8 iAlphasampledepth;
mng_uint8 iAlphacompression;
mng_uint8 iAlphafilter;
mng_uint8 iAlphainterlace;
if( mng_getchunk_jhdr( hMNG, hChunk,
&iWidth, &iHeight, &iColortype, &iImagesampledepth,
&iImagecompression, &iImageinterlace,
&iAlphasampledepth, &iAlphacompression,
&iAlphafilter, &iAlphainterlace ) != 0 )
return false;
IARG( "iWidth", iWidth );
NL; IARG( "iHeight", iHeight );
NL; IARG( "iColortype", iColortype ); MI_JPEG_COLORTYPE( iColortype );
NL; IARG( "iImagesampledepth", iImagesampledepth ); MI_JPEG_BITDEPTH( iImagesampledepth );
NL; IARG( "iImagecompression", iImagecompression ); MI_JPEGCOMPRESSION( iImagecompression );
NL; IARG( "iImageinterlace", iImageinterlace ); MI_JPEGINTERLACE( iImageinterlace );
NL; IARG( "iAlphasampledepth", iAlphasampledepth ); MI_ALPHABITDEPTH( iAlphasampledepth );
NL; IARG( "iAlphacompression", iAlphacompression ); MI_COMPRESSION_DEFLATE( iAlphacompression );
NL; IARG( "iAlphafilter", iAlphafilter ); MI_FILTER( iAlphafilter );
NL; IARG( "iAlphainterlace", iAlphainterlace ); MI_INTERLACE( iAlphainterlace );
return true;
# undef MI_JPEG_COLORTYPE
# undef MI_JPEG_BITDEPTH
# undef MI_JPEGCOMPRESSION
# undef MI_JPEGINTERLACE
# undef MI_ALPHABITDEPTH
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_LOOP( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_TERMINATION( _i_ )\
if( WantsMacroIds() )\
switch( (_i_) ) {\
case MNG_TERMINATION_DECODER_NC :\
MI( "MNG_TERMINATION_DECODER_NC" ); break;\
case MNG_TERMINATION_USER_NC :\
MI( "MNG_TERMINATION_USER_NC" ); break;\
case MNG_TERMINATION_EXTERNAL_NC :\
MI( "MNG_TERMINATION_EXTERNAL_NC" ); break;\
case MNG_TERMINATION_DETERMINISTIC_NC :\
MI( "MNG_TERMINATION_DETERMINISTIC_NC" ); break;\
case MNG_TERMINATION_DECODER_C :\
MI( "MNG_TERMINATION_DECODER_C" ); break;\
case MNG_TERMINATION_USER_C :\
MI( "MNG_TERMINATION_USER_C" ); break;\
case MNG_TERMINATION_EXTERNAL_C :\
MI( "MNG_TERMINATION_EXTERNAL_C" ); break;\
case MNG_TERMINATION_DETERMINISTIC_C :\
MI( "MNG_TERMINATION_DETERMINISTIC_C" ); break;\
default : MI(UNKNOWN);\
}
mng_uint8 iLevel;
mng_uint32 iRepeat;
mng_uint8 iTermination;
mng_uint32 iItermin;
mng_uint32 iItermax;
mng_uint32 iCount;
mng_uint32p pSignals;
if( mng_getchunk_loop( hMNG, hChunk,
&iLevel, &iRepeat, &iTermination,
&iItermin, &iItermax, &iCount, &pSignals ) != 0 )
return false;
IARG( "iLevel", iLevel );
NL; IARG( "iRepeat", iRepeat );
NL; IARG( "iTermination", iTermination ); MI_TERMINATION( iTermination );
NL; IARG( "iItermin", iItermin );
NL; IARG( "iItermax", iItermax );
NL; IARG( "iCount", iCount );
//pSignals pSignals //@todo@
return true;
# undef MI_TERMINATION
}
//---------------------------------------------------------------------------
/*
bool __fastcall TMainForm::Info_M?GN( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint16 iFirstid;
mng_uint16 iLastid;
mng_uint16 iMethodX;
mng_uint16 iMX;
mng_uint16 iMY;
mng_uint16 iML;
mng_uint16 iMR;
mng_uint16 iMT;
mng_uint16 iMB;
mng_uint16 iMethodY;
if( mng_getchunk_magn( hMNG, hChunk,
&iFirstid, &iLastid,
&iMethodX, &iMX, &iMY, &iML, &iMR, &iMT, &iMB,
&iMethodY ) != 0 )
return false;
IARG( "iFirstid", iFirstid );
NL; IARG( "iLastid", iLastid );
NL; IARG( "iMethodX", iMethodX );
NL; IARG( "iMX", iMX );
NL; IARG( "iMY", iMY );
NL; IARG( "iML", iML );
NL; IARG( "iMR", iMR );
NL; IARG( "iMT", iMT );
NL; IARG( "iMB", iMB );
NL; IARG( "iMethodY", iMethodY );
return true;
}
*/
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_MEND( mng_handle hMNG, mng_handle hChunk, String &as )
{
NL + TAB; STR( "End of Multiply Network Graphic." );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_MHDR( mng_handle hMNG, mng_handle hChunk, String &as )
{
// NB "iSimplicity" is a bit field
# define MI_SIMPLICITY( _i_ )\
if( WantsMacroIds() ) {\
if( (_i_) & MNG_SIMPLICITY_VALID )\
MI( "MNG_SIMPLICITY_VALID" );\
if( (_i_) & MNG_SIMPLICITY_SIMPLEFEATURES )\
MI( "MNG_SIMPLICITY_SIMPLEFEATURES" );\
if( (_i_) & MNG_SIMPLICITY_COMPLEXFEATURES )\
MI( "MNG_SIMPLICITY_COMPLEXFEATURES" );\
if( (_i_) & MNG_SIMPLICITY_TRANSPARENCY )\
MI( "MNG_SIMPLICITY_TRANSPARENCY" );\
if( (_i_) & MNG_SIMPLICITY_JNG )\
MI( "MNG_SIMPLICITY_JNG" );\
if( (_i_) & MNG_SIMPLICITY_DELTAPNG )\
MI( "MNG_SIMPLICITY_DELTAPNG" );\
}
mng_uint32 iWidth;
mng_uint32 iHeight;
mng_uint32 iTicks;
mng_uint32 iLayercount;
mng_uint32 iFramecount;
mng_uint32 iPlaytime;
mng_uint32 iSimplicity;
if( mng_getchunk_mhdr( hMNG, hChunk,
&iWidth, &iHeight, &iTicks,
&iLayercount, &iFramecount, &iPlaytime,
&iSimplicity ) != 0 )
return false;
IARG( "iWidth", iWidth );
NL; IARG( "iHeight", iHeight );
NL; IARG( "iTicks", iTicks );
NL; IARG( "iLayercount", iLayercount );
NL; IARG( "iFramecount", iFramecount );
NL; IARG( "iPlaytime", iPlaytime );
NL; IARG( "iSimplicity", iSimplicity ); MI_SIMPLICITY( iSimplicity );
return true;
# undef MI_SIMPLICITY
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_MOVE( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint16 iFirstid;
mng_uint16 iLastid;
mng_uint8 iMovetype;
mng_int32 iMovex;
mng_int32 iMovey;
if( mng_getchunk_move( hMNG, hChunk,
&iFirstid, &iLastid, &iMovetype, &iMovex, &iMovey ) != 0 )
return false;
IARG( "iFirstid", iFirstid );
NL; IARG( "iLastid", iLastid );
NL; IARG( "iMovetype", iMovetype ); MI_LOCATION( iMovetype );
NL; IARG( "iMovex", iMovex );
NL; IARG( "iMovey", iMovey );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_ORDR( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iCount;
if( mng_getchunk_ordr( hMNG, hChunk, &iCount ) != 0 )
return false;
IARG( "iCount", iCount );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_PAST( mng_handle hMNG, mng_handle hChunk, String &as )
{
// PAST
# define MI_TARGET( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_TARGET_ABSOLUTE : MI( "MNG_TARGET_ABSOLUTE" ); break;\
case MNG_TARGET_RELATIVE_SAMEPAST : MI( "MNG_TARGET_RELATIVE_SAMEPAST" ); break;\
case MNG_TARGET_RELATIVE_PREVPAST : MI( "MNG_TARGET_RELATIVE_PREVPAST" ); break;\
default : MI(UNKNOWN);\
}
// COMPOSITE, ORIENTATION, OFFSET & BOUNDARY depend upon "iCount"
mng_uint16 iDestid;
mng_uint8 iTargettype;
mng_int32 iTargetx;
mng_int32 iTargety;
mng_uint32 iCount;
if( mng_getchunk_past( hMNG, hChunk,
&iDestid, &iTargettype, &iTargetx, &iTargety, &iCount ) != 0 )
return false;
IARG( "iDestid", iDestid );
NL; IARG( "iTargettype", iTargettype ); MI_TARGET( iTargettype );
NL; IARG( "iTargetx", iTargetx );
NL; IARG( "iTargety", iTargety );
NL; IARG( "iCount", iCount );
return true;
# undef MI_TARGET
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_PLTE( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iCount;
mng_palette8 aPalette;
mng_uint32 iPalEntry;
if( mng_getchunk_plte( hMNG, hChunk, &iCount, &aPalette ) != 0 )
return false;
IARG( "iCount", iCount );
if( WantsPaletteEntries() )
{
iPalEntry = 0;
do{
if( WantsRgbOrder() )
{
as = as + nl +
TAB + "Palette entry [" + PadInt( iPalEntry ) + "]" +
TAB + "R(" + PadInt( aPalette[ iPalEntry ].iRed ) + ") " +
TAB + "G(" + PadInt( aPalette[ iPalEntry ].iGreen ) + ") " +
TAB + "B(" + PadInt( aPalette[ iPalEntry ].iBlue ) + ")";
}
else
{
as = as + nl +
TAB + "Palette entry [" + PadInt( iPalEntry ) + "]" +
TAB + "B(" + PadInt( aPalette[ iPalEntry ].iBlue ) + ") " +
TAB + "G(" + PadInt( aPalette[ iPalEntry ].iGreen ) + ") " +
TAB + "R(" + PadInt( aPalette[ iPalEntry ].iRed ) + ")";
};
iPalEntry += 1;
} while( iPalEntry < iCount );
}
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_PPLT( mng_handle hMNG, mng_handle hChunk, String &as )
{
/*
# define MI_DELTATYPE( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_DELTATYPE_REPLACERGB : MI( "MNG_DELTATYPE_REPLACERGB" ); break;\
case MNG_DELTATYPE_DELTARGB : MI( "MNG_DELTATYPE_DELTARGB" ); break;\
case MNG_DELTATYPE_REPLACEALPHA : MI( "MNG_DELTATYPE_REPLACEALPHA" ); break;\
case MNG_DELTATYPE_DELTAALPHA : MI( "MNG_DELTATYPE_DELTAALPHA" ); break;\
case MNG_DELTATYPE_REPLACERGBA : MI( "MNG_DELTATYPE_REPLACERGBA" ); break;\
case MNG_DELTATYPE_DELTARGBA : MI( "MNG_DELTATYPE_DELTARGBA" ); break;\
default : MI(UNKNOWN);\
}
*/
mng_uint32 iCount;
if( mng_getchunk_pplt( hMNG, hChunk, &iCount ) != 0 )
return false;
IARG( "iCount", iCount );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_PROM( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_FILLMETHOD( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_FILLMETHOD_LEFTBITREPLICATE : MI( "MNG_FILLMETHOD_LEFTBITREPLICATE" ); break;\
case MNG_FILLMETHOD_ZEROFILL : MI( "MNG_FILLMETHOD_ZEROFILL" ); break;\
default : MI(UNKNOWN);\
}
mng_uint8 iColortype;
mng_uint8 iSampledepth;
mng_uint8 iFilltype;
if( mng_getchunk_prom( hMNG, hChunk,
&iColortype, &iSampledepth, &iFilltype ) != 0 )
return false;
IARG( "iColortype", iColortype ); MI_COLORTYPE( iColortype );
NL; IARG( "iSampledepth", iSampledepth ); MI_BITDEPTH( iSampledepth );
NL; IARG( "iFilltype", iFilltype ); MI_FILLMETHOD( iFilltype );
return true;
# undef MI_FILLMETHOD
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_SAVE( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_SAVEOFFSET( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_SAVEOFFSET_4BYTE : MI( "MNG_SAVEOFFSET_4BYTE" ); break;\
case MNG_SAVEOFFSET_8BYTE : MI( "MNG_SAVEOFFSET_8BYTE" ); break;\
default : MI(UNKNOWN);\
}
/*
# define MI_SAVEENTRY( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_SAVEENTRY_SEGMENTFULL : MI( "MNG_SAVEENTRY_SEGMENTFULL" ); break;\
case MNG_SAVEENTRY_SEGMENT : MI( "MNG_SAVEENTRY_SEGMENT" ); break;\
case MNG_SAVEENTRY_SUBFRAME : MI( "MNG_SAVEENTRY_SUBFRAME" ); break;\
case MNG_SAVEENTRY_EXPORTEDIMAGE : MI( "MNG_SAVEENTRY_EXPORTEDIMAGE" ); break;\
default : MI(UNKNOWN);\
}
*/
mng_bool bEmpty;
mng_uint8 iOffsettype;
mng_uint32 iCount;
if( mng_getchunk_save( hMNG, hChunk,
&bEmpty, &iOffsettype, &iCount ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; IARG( "iOffsettype", iOffsettype ); MI_SAVEOFFSET( iOffsettype );
NL; IARG( "iCount", iCount );
return true;
# undef MI_SAVEOFFSET
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_SEEK( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iNamesize;
mng_pchar zName;
if( mng_getchunk_seek( hMNG, hChunk, &iNamesize, &zName ) != 0 )
return false;
IARG( "iNamesize", iNamesize );
NL; ZARG( "zName", zName );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_SHOW( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_SHOWMODE( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_SHOWMODE_0 : MI( "MNG_SHOWMODE_0" ); break;\
case MNG_SHOWMODE_1 : MI( "MNG_SHOWMODE_1" ); break;\
case MNG_SHOWMODE_2 : MI( "MNG_SHOWMODE_2" ); break;\
case MNG_SHOWMODE_3 : MI( "MNG_SHOWMODE_3" ); break;\
case MNG_SHOWMODE_4 : MI( "MNG_SHOWMODE_4" ); break;\
case MNG_SHOWMODE_5 : MI( "MNG_SHOWMODE_5" ); break;\
case MNG_SHOWMODE_6 : MI( "MNG_SHOWMODE_6" ); break;\
case MNG_SHOWMODE_7 : MI( "MNG_SHOWMODE_7" ); break;\
default : MI(UNKNOWN);\
}
mng_bool bEmpty;
mng_uint16 iFirstid;
mng_uint16 iLastid;
mng_uint8 iMode;
if( mng_getchunk_show( hMNG, hChunk,
&bEmpty, &iFirstid, &iLastid, &iMode ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; IARG( "iFirstid", iFirstid );
NL; IARG( "iLastid", iLastid );
NL; IARG( "iMode", iMode ); MI_SHOWMODE( iMode );
return true;
# undef MI_SHOWMODE
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_TERM( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_TERMACTION( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_TERMACTION_LASTFRAME : MI( "MNG_TERMACTION_LASTFRAME" ); break;\
case MNG_TERMACTION_CLEAR : MI( "MNG_TERMACTION_CLEAR" ); break;\
case MNG_TERMACTION_FIRSTFRAME : MI( "MNG_TERMACTION_FIRSTFRAME" ); break;\
case MNG_TERMACTION_REPEAT : MI( "MNG_TERMACTION_REPEAT" ); break;\
default : MI(UNKNOWN);\
}
# define MI_ITERACTION( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_ITERACTION_LASTFRAME : MI( "MNG_ITERACTION_LASTFRAME" ); break;\
case MNG_ITERACTION_CLEAR : MI( "MNG_ITERACTION_CLEAR" ); break;\
case MNG_ITERACTION_FIRSTFRAME : MI( "MNG_ITERACTION_FIRSTFRAME" ); break;\
default : MI(UNKNOWN);\
}
mng_uint8 iTermaction;
mng_uint8 iIteraction;
mng_uint32 iDelay;
mng_uint32 iItermax;
if( mng_getchunk_term( hMNG, hChunk,
&iTermaction, &iIteraction, &iDelay, &iItermax ) != 0 )
return false;
IARG( "iTermaction", iTermaction ); MI_TERMACTION( iTermaction );
NL; IARG( "iIteraction", iIteraction ); MI_ITERACTION( iIteraction );
NL; IARG( "iDelay", iDelay );
NL; IARG( "iItermax", iItermax );
return true;
# undef MI_TERMACTION
# undef MI_ITERACTION
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_bKGD( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_bool bEmpty;
mng_uint8 iType;
mng_uint8 iIndex;
mng_uint16 iGray;
mng_uint16 iRed;
mng_uint16 iGreen;
mng_uint16 iBlue;
if( mng_getchunk_bkgd( hMNG, hChunk,
&bEmpty, &iType, &iIndex, &iGray,
&iRed, &iGreen, &iBlue ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; IARG( "iType", iType );
NL; IARG( "iIndex", iIndex );
NL; IARG( "iGray", iGray );
NL; IARG( "iRed", iRed );
NL; IARG( "iGreen", iGreen );
NL; IARG( "iBlue", iBlue );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_cHRM( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_bool bEmpty;
mng_uint32 iWhitepointx;
mng_uint32 iWhitepointy;
mng_uint32 iRedx;
mng_uint32 iRedy;
mng_uint32 iGreenx;
mng_uint32 iGreeny;
mng_uint32 iBluex;
mng_uint32 iBluey;
if( mng_getchunk_chrm( hMNG, hChunk,
&bEmpty, &iWhitepointx, &iWhitepointy,
&iRedx, &iRedy,
&iGreenx,&iGreeny,
&iBluex, &iBluey ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; FARG( "iWhitepointx", iWhitepointx );
FPCOM( String( (float)(iWhitepointx /FFACTOR) ) );
NL; FARG( "iWhitepointy", iWhitepointy );
FPCOM( String( (float)(iWhitepointy /FFACTOR) ) );
NL; FARG( "iRedx", iRedx );
FPCOM( String( (float)(iRedx /FFACTOR) ) );
NL; FARG( "iRedy", iRedy );
FPCOM( String( (float)(iRedy /FFACTOR) ) );
NL; FARG( "iGreenx", iGreenx );
FPCOM( String( (float)(iGreenx /FFACTOR) ) );
NL; FARG( "iGreeny", iGreeny );
FPCOM( String( (float)(iGreeny /FFACTOR) ) );
NL; FARG( "iBluex", iBluex );
FPCOM( String( (float)(iBluex /FFACTOR) ) );
NL; FARG( "iBluey", iBluey );
FPCOM( String( (float)(iBluey /FFACTOR) ) );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_eXPI( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint16 iSnapshotid;
mng_uint32 iNamesize;
mng_pchar zName;
if( mng_getchunk_expi( hMNG, hChunk,
&iSnapshotid, &iNamesize, &zName ) != 0 )
return false;
IARG( "iSnapshotid", iSnapshotid );
NL; IARG( "iNamesize", iNamesize );
NL; ZARG( "zName", zName );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_fPRI( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_PRIORITY( _i_ )\
if( WantsMacroIds() )\
switch( _i_ ) {\
case MNG_PRIORITY_ABSOLUTE : MI( "MNG_PRIORITY_ABSOLUTE" ); break;\
case MNG_PRIORITY_RELATIVE : MI( "MNG_PRIORITY_RELATIVE" ); break;\
default : MI(UNKNOWN);\
}
mng_uint8 iDeltatype;
mng_uint8 iPriority;
if( mng_getchunk_fpri( hMNG, hChunk, &iDeltatype, &iPriority ) != 0 )
return false;
IARG( "iDeltatype", iDeltatype ); MI_PRIORITY( iDeltatype );
NL; IARG( "iPriority", iPriority );
return true;
# undef MI_PRIORITY
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_gAMA( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_bool bEmpty;
mng_uint32 iGamma;
if( mng_getchunk_gama( hMNG, hChunk, &bEmpty, &iGamma ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; FARG( "iGamma", iGamma );
FPCOM( String( (float)(iGamma /FFACTOR) ) );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_hIST( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iEntrycount;
mng_uint16arr aEntries;
if( mng_getchunk_hist( hMNG, hChunk, &iEntrycount, &aEntries ) != 0 )
return false;
IARG( "iEntrycount", iEntrycount );
//aEntries aEntries @todo@
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_iCCP( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_bool bEmpty;
mng_uint32 iNamesize;
mng_pchar zName;
mng_uint8 iCompression;
mng_uint32 iProfilesize;
mng_ptr pProfile;
if( mng_getchunk_iccp( hMNG, hChunk,
&bEmpty, &iNamesize, &zName, &iCompression,
&iProfilesize,&pProfile ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; IARG( "iNamesize", iNamesize );
NL; ZARG( "Name", zName );
NL; IARG( "iCompression", iCompression ); MI_COMPRESSION_DEFLATE( iCompression );
NL; IARG( "iProfilesize", iProfilesize );
// "pProfile " + String( pProfile );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_iTXt( mng_handle hMNG, mng_handle hChunk, String &as )
{
#define MI_ITXT_FLAG( _i_ )\
if( WantsMacroIds() ) {\
if( (_i_) == MNG_FLAG_UNCOMPRESSED ) {\
MI( "MNG_FLAG_UNCOMPRESSED" )\
} else if( (_i_) == MNG_FLAG_COMPRESSED ) {\
MI( "MNG_FLAG_COMPRESSED" );\
}\
}
mng_uint32 iKeywordsize;
mng_pchar zKeyword;
mng_uint8 iCompressionflag;
mng_uint8 iCompressionmethod;
mng_uint32 iLanguagesize;
mng_pchar zLanguage;
mng_uint32 iTranslationsize;
mng_pchar zTranslation;
mng_uint32 iTextsize;
mng_pchar zText;
if( mng_getchunk_itxt( hMNG, hChunk,
&iKeywordsize, &zKeyword,
&iCompressionflag, &iCompressionmethod,
&iLanguagesize, &zLanguage,
&iTranslationsize, &zTranslation,
&iTextsize, &zText ) != 0 )
return false;
IARG( "iKeywordsize", iKeywordsize );
NL; ZARG( "zKeyword", zKeyword );
NL; IARG( "iCompressionflag", iCompressionflag ); MI_ITXT_FLAG( iCompressionflag );
NL; IARG( "iCompressionmethod", iCompressionmethod ); MI_COMPRESSION_DEFLATE( iCompressionflag );
NL; IARG( "iLanguagesize", iLanguagesize );
NL; ZARG( "zLanguage", zLanguage );
NL; IARG( "iTranslationsize", iTranslationsize );
NL; ZARG( "zTranslation", zTranslation );
NL; IARG( "iTextsize", iTextsize );
NL; ZARG( "zText", zText );
return true;
# undef MI_ITXT_FLAG
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_nEED( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iKeywordssize;
mng_pchar zKeywords;
if( mng_getchunk_need( hMNG, hChunk, &iKeywordssize, &zKeywords ) != 0)
return false;
IARG( "iKeywordssize", iKeywordssize );
NL; IARG( "zKeywords", zKeywords );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_pHYg( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_bool bEmpty;
mng_uint32 iSizex;
mng_uint32 iSizey;
mng_uint8 iUnit;
if( mng_getchunk_phyg( hMNG, hChunk,
&bEmpty, &iSizex, &iSizey, &iUnit ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; IARG( "iSizex", iSizex );
NL; IARG( "iSizey", iSizey );
NL; IARG( "iUnit", iUnit ); MI_UNITS( iUnit );
if( iUnit ) {
PCOM("X/Y pixels per unit" );
} else {
if( iSizex == iSizey ) {
PCOM( "Square pixels" );
}
}
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_pHYs( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_bool bEmpty;
mng_uint32 iSizex;
mng_uint32 iSizey;
mng_uint8 iUnit;
if( mng_getchunk_phys( hMNG, hChunk,
&bEmpty, &iSizex, &iSizey, &iUnit ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; IARG( "iSizex", iSizex );
NL; IARG( "iSizey", iSizey );
NL; IARG( "iUnit", iUnit ); MI_UNITS( iUnit );
if( iUnit ) {
PCOM("X/Y pixels per unit" );
} else {
if( iSizex == iSizey ) {
PCOM( "Square pixels" );
}
}
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_sBIT( mng_handle hMNG, mng_handle hChunk, String &as )
{ // tested with cs3* cs5* cs8*
mng_bool bEmpty;
mng_uint8 iType;
mng_uint8arr4 aBits;
if( mng_getchunk_sbit( hMNG, hChunk, &bEmpty, &iType, &aBits ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; IARG( "iType", iType );
//aBits aBits @todo@
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_sPLT( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_bool bEmpty;
mng_uint32 iNamesize;
mng_pchar zName;
mng_uint8 iSampledepth;
mng_uint32 iEntrycount;
mng_ptr pEntries;
if( mng_getchunk_splt( hMNG, hChunk,
&bEmpty, &iNamesize, &zName,
&iSampledepth, &iEntrycount, &pEntries ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; IARG( "iNamesize", iNamesize );
NL; ZARG( "zName", zName );
NL; IARG( "iSampledepth", iSampledepth ); MI_BITDEPTH( iSampledepth );
NL; IARG( "iEntrycount", iEntrycount );
//pEntries pEntries @todo@
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_sRGB( mng_handle hMNG, mng_handle hChunk, String &as )
{
# define MI_RENDERINGINTENT( _i_ )\
if( WantsMacroIds() ) {\
switch( (_i_) ) {\
case MNG_INTENT_PERCEPTUAL :\
MI( "MNG_INTENT_PERCEPTUAL" ); break;\
case MNG_INTENT_RELATIVECOLORIMETRIC :\
MI( "MNG_INTENT_RELATIVECOLORIMETRIC" );break;\
case MNG_INTENT_SATURATION :\
MI( "MNG_INTENT_SATURATION" ); break;\
case MNG_INTENT_ABSOLUTECOLORIMETRIC :\
MI( "MNG_INTENT_ABSOLUTECOLORIMETRIC" );break;\
}\
}
mng_bool bEmpty;
mng_uint8 iRenderingintent;
if( mng_getchunk_srgb( hMNG, hChunk,&bEmpty, &iRenderingintent ) != 0)
return false;
BARG( "bEmpty", bEmpty );
NL; IARG( "iRenderingintent", iRenderingintent );
MI_RENDERINGINTENT( iRenderingintent );
return true;
# undef MI_RENDERINGINTENT
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_tEXt( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iKeywordsize;
mng_pchar zKeyword;
mng_uint32 iTextsize;
mng_pchar zText;
if( mng_getchunk_text( hMNG, hChunk,
&iKeywordsize, &zKeyword, &iTextsize, &zText ) != 0 )
return false;
IARG( "iKeywordsize", iKeywordsize );
NL; ZARG( "zKeyword", zKeyword );
NL; IARG( "iTextsize", iTextsize );
NL; ZARG( "zText", zText );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_tIME( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint16 iYear;
mng_uint8 iMonth;
mng_uint8 iDay;
mng_uint8 iHour;
mng_uint8 iMinute;
mng_uint8 iSecond;
if( mng_getchunk_time( hMNG, hChunk,
&iYear, &iMonth, &iDay, &iHour, &iMinute, &iSecond ) != 0 )
return false;
IARG( "iYear", iYear );
NL; IARG( "iMonth", iMonth );
NL; IARG( "iDay", iDay );
NL; IARG( "iHour", iHour );
NL; IARG( "iMinute", iMinute );
NL; IARG( "iSecond", iSecond );
// Do not do help line here - may confuse international readers !
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_tRNS( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_bool bEmpty;
mng_bool bGlobal;
mng_uint8 iType;
mng_uint32 iCount;
mng_uint8arr aAlphas;
mng_uint16 iGray;
mng_uint16 iRed;
mng_uint16 iGreen;
mng_uint16 iBlue;
mng_uint32 iRawlen;
mng_uint8arr aRawdata;
if( mng_getchunk_trns( hMNG, hChunk,
&bEmpty, &bGlobal, &iType, &iCount,
&aAlphas,
&iGray, &iRed, &iGreen, &iBlue,
&iRawlen,
&aRawdata ) != 0 )
return false;
BARG( "bEmpty", bEmpty );
NL; BARG( "bGlobal", bGlobal );
NL; IARG( "iType", iType );
NL; IARG( "iCount", iCount );
//aAlphas aAlphas @todo@
NL; IARG( "iGray", iGray );
NL; IARG( "iRed", iRed );
NL; IARG( "iGreen", iGreen );
NL; IARG( "iBlue", iBlue );
NL; IARG( "iRawlen", iRawlen );
//aRawdata aRawdata @todo@
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_zTXt( mng_handle hMNG, mng_handle hChunk, String &as )
{
mng_uint32 iKeywordsize;
mng_pchar zKeyword;
mng_uint8 iCompression;
mng_uint32 iTextsize;
mng_pchar zText;
if( mng_getchunk_ztxt( hMNG, hChunk,
&iKeywordsize, &zKeyword, &iCompression, &iTextsize, &zText ) != 0 )
return false;
IARG( "iKeywordsize", iKeywordsize );
NL; ZARG( "zKeyword", zKeyword );
NL; IARG( "iCompression", iCompression ); MI_COMPRESSION_DEFLATE( iCompression );
NL; IARG( "iTextsize", iTextsize );
NL; ZARG( "zText", zText );
return true;
}
//---------------------------------------------------------------------------
bool __fastcall TMainForm::Info_Unknown( mng_handle hMNG, mng_handle hChunk, String &as )
{
NL + TAB; STR( "Unknown Chunk" );
NL + TAB; STR( nl + TAB + "(See help tab for a list of unsupported chunks)!" );
return true;
}
//---------------------------------------------------------------------------
Reference in a new issue View git blame Copy permalink