String OutputStr::GetInfo(bool raw) const
{
String str;
int count= tags_.size();
for (int i= 0; i < count; ++i)
{
TCHAR buf[MAX_PATH];
// memset(buf, 0xff, 2*(MAX_PATH + 5));
GetTagText(i, buf, MAX_PATH);
// if (buf[MAX_PATH] != 0xffff) { ASSERT(false); }
str.append(buf);
str += _T('\t');
GetNameText(i, buf, MAX_PATH);
// if (buf[MAX_PATH] != 0xffff) { ASSERT(false); }
str.append(buf);
str += _T('\t');
if (raw)
GetValueText(i, buf, MAX_PATH);
else
GetInterpretedText(i, buf, MAX_PATH);
//if (buf[MAX_PATH] != 0xffff) { ASSERT(false); }
//if (_tcslen(buf) >= MAX_PATH - 1)
//{ ASSERT(false); }
str.append(buf);
str.append(_T("\r\n"));
}
return str;
}
void InfoPane::GetLineText(int line, int col, TCHAR* text, int max_len)
{
if (line < 0)
{
line += LINE_LAST;
switch (col)
{
case 0: // no tag
text[0] = _T('-');
text[1] = _T('\0');
break;
case 1: // name
GetNameText(line, text, max_len);
break;
case 2: // value
GetValueText(line, text, max_len);
break;
}
}
else if (photo_ != 0 && line < file_info_.Count())
{
switch (col)
{
case 0: // tag
file_info_.GetTagText(line, text, max_len);
break;
case 1: // name
file_info_.GetNameText(line, text, max_len);
break;
case 2: // value
if (raw_data_)
file_info_.GetValueText(line, text, max_len);
else
file_info_.GetInterpretedText(line, text, max_len);
break;
}
}
else if (line == file_info_.Count() && photo_->GetColorProfile() != 0)
{
switch (col)
{
case 0: // tag
*text = 0;
break;
case 1: // name
_tcsncpy(text, _T("Embedded ICC Profile"), max_len);
break;
case 2: // value
_tcsncpy(text, photo_->GetColorProfile()->GetProductInfo().c_str(), max_len);
break;
}
}
}
void GetTextureNameText( INDEX iWorld, INDEX iTexture, char *buf, int bufsize )
{
PWORLD world = GetSetMember( WORLD, &g.worlds, iWorld );
PFLATLAND_TEXTURE texture;
if( iTexture == INVALID_INDEX )
return;
texture = GetSetMember( FLATLAND_TEXTURE, &world->textures, iTexture );
GetNameText( iWorld, texture->iName, buf, bufsize );
}
uintptr_t CPROC CompareWorldName( POINTER p, uintptr_t psv )
{
CTEXTSTR name = (CTEXTSTR)psv;
PWORLD world = (PWORLD)p;
TEXTCHAR buffer[256];
GetNameText( GetMemberIndex( WORLD, &g.worlds, world ), world->name, buffer, sizeof( buffer ) );
if( StrCmp( buffer, name ) == 0 )
return (uintptr_t)world;
return 0;
}
static INDEX CPROC FindTextureName( INDEX texture, uintptr_t psv )
{
PFINDTHING pft = ( PFINDTHING)psv;
TEXTCHAR textname[256];
TEXTCHAR name[256];
GetTextureNameText( pft->iWorld, texture, textname, sizeof( textname ) );
GetNameText( pft->iWorld, pft->iName, name, sizeof( name ) );
if( !StrCmp( name, textname ) )
{
return texture;
}
return INVALID_INDEX;
}
void SGDisplayDATATYPE::HandleRedraw(SGRedrawInfo *RedrawInfo, SGMiscInfo *MiscInfo)
{
// First, inform the system that we are about to start rendering this item
StartRendering(RedrawInfo, MiscInfo);
DocRect MyRect(FormatRect); // Get my redraw position from the cached FormatRect
RenderRegion *Renderer = RedrawInfo->Renderer;
INT32 OnePixel = (INT32) DevicePixels(MiscInfo, 1);
INT32 TwoPixels = (INT32) DevicePixels(MiscInfo, 2);
Renderer->SetLineWidth(0);
Renderer->SetLineColour(RedrawInfo->Transparent);
// First, render the icon at the left end of our rectangle
DocRect IconRect(MyRect);
IconRect.hi.x = IconRect.lo.x + IconRect.Height(); // Make it a square
MyRect.lo.x = IconRect.hi.x + TwoPixels; // And exclude it from 'MyRect'
// Redraw the icon
GridLockRect(MiscInfo, &IconRect); // Ensure it maps exactly to specific pixels
IconRect.Inflate(-OnePixel, -OnePixel); // Leave a bit of space around the edge
Renderer->SetFillColour(DocColour(COLOUR_RED));
Renderer->DrawRect(&IconRect);
GridLockRect(MiscInfo, &MyRect); // Ensure the new 'MyRect' is pixel-grid-aligned
// Set up the colours for rendering our text, and fill the background if selected
if (Flags.Selected)
{
// Fill the entire background with the 'selected' colour, so we don't
// get gaps between bits of text or uneven rectangles in multiple selections
Renderer->SetFillColour(RedrawInfo->SelBackground);
Renderer->DrawRect(&MyRect);
Renderer->SetFixedSystemTextColours(&RedrawInfo->SelForeground, &RedrawInfo->SelBackground);
}
else
Renderer->SetFixedSystemTextColours(&RedrawInfo->Foreground, &RedrawInfo->Background);
MyRect.lo.x += SG_GapBeforeText; // Leave a small gap before text begins
// And render the text
String_256 MyText;
GetNameText(&MyText);
Renderer->DrawFixedSystemText(&MyText, MyRect);
// Finally, inform the system that we have completed rendering this item
StopRendering(RedrawInfo, MiscInfo);
}
int SrvrLoadWorldFromFile( uint32_t client_id, FILE *file, INDEX iWorld )
{
FILE *pFile;
PWORLD world = GetSetMember( WORLD, &g.worlds, iWorld );
int sz = 0, cnt, version, size;
char tag[4]; // read in make sure we're still aligned in the file...
int linesize;
int nlines;
PFLATLAND_MYLINESEG *linearray;
int wallsize;
int nwalls;
PWALL *wallarray;
int sectorsize;
int nsectors;
PSECTOR *sectorarray;
int namesize;
int nnames;
PNAME *namearray;
int texturesize;
int ntextures;
PFLATLAND_TEXTURE *texturearray;
INDEX texture;
if( !world )
return 0;
{
char buffer[256];
GetNameText( iWorld, world->name, buffer, sizeof( buffer ) );
Fopen( pFile, buffer, "rb" );
}
if( !pFile )
return 0;
ResetWorld( iWorld ); // make sure this thing is empty );
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "FLAT", 4 ) )
{
Log( "Alignment error in file load... totally invalid file." );
return 0;
}
sz += fread( &size, 1, sizeof( size ), pFile );
if( size < 10 ) // can assume that it was a version ID
version = size;
else
sz = fread( &version, 1, sizeof( version ), pFile );
if( version < 8 )
{
texture = SrvrMakeTexture( client_id, iWorld, SrvrMakeName( client_id, iWorld, WIDE( "Default" ) ) );
SrvrSetSolidColor( client_id, iWorld, texture, AColor( 43, 76, 180, 0x80 ) );
}
Log1( "Loading version: %d", version );
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "LINE", 4 ) )
{
// was not LINE or FLAT tag...
Log( "Alignment error in file line load." );
return 0;
}
if( version > 9 )
sz += fread( &linesize, 1, sizeof( linesize ), pFile );
sz += fread( &nlines, 1, sizeof(nlines), pFile );
linearray = (PFLATLAND_MYLINESEG*)Allocate( sizeof( PFLATLAND_MYLINESEG ) * nlines );
for( cnt = 0; cnt < nlines; cnt++ )
{
PFLATLAND_MYLINESEG pls;
LINESEGFILE lsf;
sz += fread( &lsf, 1, sizeof(LINESEGFILE), pFile );
pls = GetFromSet( FLATLAND_MYLINESEG, &world->lines );
#ifdef OUTPUT_TO_VIRTUALITY
pls->pfl = CreateFacetLine( world->object, lsf.r.o, lsf.r.n, lsf.start, lsf.end );
#endif
linearray[cnt] = pls;
/* some sort of update line... */
SetRay( &pls->r, &lsf.r );
if( version < 9 )
{
pls->r.o[1] = -pls->r.o[1];
pls->r.n[1] = -pls->r.n[1];
}
pls->dFrom = lsf.start;
pls->dTo = lsf.end;
}
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "WALL", 4 ) )
{
Log( "Alignment error in file wall load." );
return 0;
}
if( version > 9 )
sz += fread( &wallsize, 1, sizeof( wallsize ), pFile );
sz += fread( &nwalls, 1, sizeof(nwalls), pFile );
wallarray = (PWALL*)Allocate( sizeof( PWALL ) * nwalls );
for( cnt = 0; cnt < nwalls; cnt++ )
{
wallarray[cnt] = GetFromSet( WALL, &world->walls );
}
for( cnt = 0; cnt < nwalls; cnt++ )
{
FILEWALLV1 ReadWall1;
FILEWALLV2 ReadWall2;
PWALL pwall;
pwall = wallarray[cnt];
if( version < 2 )
{
sz += fread( &ReadWall1, 1, sizeof( FILEWALLV1 ), pFile );
pwall->flags = ReadWall1.flags;
pwall->iSector = ReadWall1.nSector;
SetLineWorld( world, pwall->iLine, linearray[ReadWall1.nLine] );
if( ReadWall1.nWallInto == -1 )
pwall->iWallInto = INVALID_INDEX;
else
pwall->iWallInto = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall1.nWallInto] );
pwall->iWallStart = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall1.nWallStart] );
pwall->iWallEnd = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall1.nWallEnd] );
}
else
{
sz += fread( &ReadWall2, 1, sizeof( FILEWALLV2 ), pFile );
pwall->flags = ReadWall2.flags;
pwall->iSector = ReadWall2.nSector;
if( ReadWall2.nLine != -1 )
{
pwall->iLine = GetMemberIndex( FLATLAND_MYLINESEG, &world->lines, linearray[ReadWall2.nLine] );
//SetLine( pwall->line, linearray[ReadWall2.nLine] );
}
else
{
Log( "Wall without line? cant be!" );
DebugBreak();
pwall->iLine = INVALID_INDEX;
}
if( ReadWall2.nWallInto == -1 )
pwall->iWallInto = INVALID_INDEX;
else
pwall->iWallInto = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall2.nWallInto] );
pwall->iWallStart = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall2.nWallStart] );
pwall->iWallEnd = GetMemberIndex( WALL, &world->walls, wallarray[ReadWall2.nWallEnd] );
}
}
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "SECT", 4 ) )
{
Log2( "Alignment error in file sector load. %s(%d)", __FILE__, __LINE__ );
return 0;
}
if( version > 9 )
sz += fread( §orsize, 1, sizeof( sectorsize ), pFile );
sz += fread( &nsectors, 1, sizeof(nsectors), pFile );
sectorarray = (PSECTOR*)Allocate( sizeof( PSECTOR ) * nsectors );
for( cnt = 0; cnt < nsectors; cnt++ )
{
FILESECTORV3 ReadSector3;
FILESECTORV4 ReadSector4;
FILESECTORV5 ReadSector5;
FILESECTORV8 ReadSector8;
INDEX sector;
sectorarray[cnt] = GetFromSet( SECTOR, &world->sectors );
#ifdef OUTPUT_TO_VIRTUALITY
sectorarray[cnt]->facet = AddNormalPlane( world->object, VectorConst_0, VectorConst_Z, 0 );
#endif
sector = GetMemberIndex( SECTOR, &world->sectors, sectorarray[cnt] );
if( version < 8 )
{
// one texture is sufficient...
// in fact textures should be highly sharable.
sectorarray[cnt]->iTexture = texture;
}
if( version < 4 )
{
/*
{
char name[20];
sprintf( name, "%d", SectorIDs++ );
sectorarray[cnt]->name = GetName( &world->names, name );
}
*/
sectorarray[cnt]->iName = INVALID_INDEX;
sz += fread( &ReadSector3, 1, sizeof( FILESECTORV3 ), pFile );
sectorarray[cnt]->flags = ReadSector3.flags;
sectorarray[cnt]->iWorld = iWorld;
SetRay( §orarray[cnt]->r, &ReadSector3.r );
sectorarray[cnt]->iWall = GetMemberIndex( WALL, &world->walls, wallarray[ReadSector3.nwall] );
if( version < 3 )
{
ComputeSectorOrigin( iWorld, sector);
}
}
else if( version < 5 )
{
sz += fread( &ReadSector4, 1, sizeof( FILESECTORV4 ), pFile );
/*
{
char name[20];
sprintf( name, "%d", ReadSector4.nID );
sectorarray[cnt]->name = GetName( &world->names, name );
if( atoi( name ) > SectorIDs )
SectorIDs = atoi( name );
}
*/
sectorarray[cnt]->iName = INVALID_INDEX;
sectorarray[cnt]->flags = ReadSector4.flags;
sectorarray[cnt]->iWorld = iWorld;
SetRay( §orarray[cnt]->r, &ReadSector4.r );
sectorarray[cnt]->iWall = GetMemberIndex( WALL, &world->walls, wallarray[ReadSector4.nwall] );
}
else if( version < 8 )
{
sz += fread( &ReadSector5, 1, sizeof( FILESECTORV5 ), pFile );
sectorarray[cnt]->iName = ReadSector5.nName;
sectorarray[cnt]->flags = ReadSector5.flags;
sectorarray[cnt]->iWorld = iWorld;
SetRay( §orarray[cnt]->r, &ReadSector5.r );
sectorarray[cnt]->iWall = GetMemberIndex( WALL, &world->walls, wallarray[ReadSector5.nwall] );
}
else
{
sz += fread( &ReadSector8, 1, sizeof( FILESECTORV8 ), pFile );
sectorarray[cnt]->iName = ReadSector8.nName;
sectorarray[cnt]->flags = ReadSector8.flags;
sectorarray[cnt]->iWorld = iWorld;
SetRay( §orarray[cnt]->r, &ReadSector8.r );
sectorarray[cnt]->iWall = ReadSector8.nwall;
sectorarray[cnt]->iTexture = ReadSector8.nTexture;
}
// walls should all be valid at this point...
// have valid lines, and valid linkings...
ComputeSectorPointList( iWorld, sector, NULL );
ComputeSectorOrigin( iWorld, sector );
#ifdef OUTPUT_TO_VIRTUALITY
OrderObjectLines( world->object );
#endif
}
// fix sector references in walls.
//for( cnt = 0; cnt < nwalls; cnt++ )
//{
// wallarray[cnt]->iSector = wallarray[cnt]->iSector;
//}
for( cnt = 0; cnt < nwalls; cnt++ )
{
if( wallarray[cnt]->iLine == INVALID_INDEX )
{
SrvrDestroySector( client_id, iWorld, wallarray[cnt]->iSector );
Log( "attempting to fix broken walls" );
break;
}
}
if( version >= 5 )
{
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "NAME", 4 ) )
{
Log2( "Alignment error in name section load. %s(%d)", __FILE__, __LINE__ );
return 0;
}
if( version > 9 )
sz += fread( &namesize, 1, sizeof( namesize ), pFile );
sz += fread( &nnames, 1, sizeof(nnames), pFile );
namearray = (PNAME*)Allocate( sizeof( PNAME ) * nnames );
for( cnt = 0; cnt < nnames; cnt++ )
{
namearray[cnt] = GetFromSet( NAME, &world->names );
if( version < 6 )
{
uint32_t length;
namearray[cnt]->name = (struct name_data*)Allocate( sizeof( *namearray[cnt]->name ) );
sz += fread( &length, 1, sizeof( length ), pFile );
namearray[cnt]->name[0].length = length;
namearray[cnt]->name[0].name = (TEXTSTR)Allocate( namearray[cnt]->name[0].length + 1 );
sz += fread( namearray[cnt]->name[0].name, 1, namearray[cnt]->name[0].length, pFile );
namearray[cnt]->name[0].name[namearray[cnt]->name[0].length] = 0;
namearray[cnt]->lines = 1;
}
else if( version < 7 )
{
int l;
sz += fread( &namearray[cnt]->lines, 1, sizeof( namearray[cnt]->lines ), pFile );
if( namearray[cnt]->lines )
{
namearray[cnt]->name = (struct name_data*)Allocate( sizeof( *namearray[cnt]->name ) * namearray[cnt]->lines );
for( l = 0; l < namearray[cnt]->lines; l++ )
{
sz += fread( &namearray[cnt]->name[l].length, 1, sizeof( namearray[cnt]->name[l].length ), pFile );
namearray[cnt]->name[l].name = (TEXTSTR)Allocate( namearray[cnt]->name[l].length + 1 );
sz += fread( namearray[cnt]->name[l].name, 1, namearray[cnt]->name[l].length, pFile );
namearray[cnt]->name[l].name[namearray[cnt]->name[l].length] = 0;
}
}
else
namearray[cnt]->name = NULL;
}
else
{
int l;
sz += fread( &namearray[cnt]->flags, 1, sizeof( namearray[cnt]->flags ), pFile );
sz += fread( &namearray[cnt]->lines, 1, sizeof( namearray[cnt]->lines ), pFile );
if( namearray[cnt]->lines )
{
namearray[cnt]->name = (struct name_data*)Allocate( sizeof( *namearray[cnt]->name ) * namearray[cnt]->lines );
for( l = 0; l < namearray[cnt]->lines; l++ )
{
sz += fread( &namearray[cnt]->name[l].length, 1, sizeof( namearray[cnt]->name[l].length ), pFile );
namearray[cnt]->name[l].name = (TEXTSTR)Allocate( namearray[cnt]->name[l].length + 1 );
sz += fread( namearray[cnt]->name[l].name, 1, namearray[cnt]->name[l].length, pFile );
namearray[cnt]->name[l].name[namearray[cnt]->name[l].length] = 0;
}
}
else
namearray[cnt]->name = NULL;
}
}
/*
for( cnt = 0; cnt < nsectors; cnt++ )
{
if( (int)sectorarray[cnt]->iName == -1 )
sectorarray[cnt]->iName = INVALID_INDEX;
else
{
int n;
PNAME pName = namearray[(int)sectorarray[cnt]->name];
if( pName->name && pName->name[0].name )
if( ( n = atoi( pName->name[0].name ) ) > SectorIDs )
SectorIDs = n;
sectorarray[cnt]->name = pName;
}
}
*/
if( version >= 8 )
{
sz += fread( tag, 1, 4, pFile );
if( strncmp( tag, "TEXT", 4 ) )
{
Log2( "Alignment error in texture section load. %s(%d)", __FILE__, __LINE__ );
return 0;
}
if( version > 9 )
sz += fread( &texturesize, 1, sizeof( texturesize ), pFile );
sz += fread( &ntextures, 1, sizeof(ntextures), pFile );
texturearray = (PFLATLAND_TEXTURE*)Allocate( sizeof( PFLATLAND_TEXTURE ) * ntextures );
for( cnt = 0; cnt < ntextures; cnt++ )
{
char flag;
int nName;
sz += fread( &nName, 1, sizeof( nName ), pFile );
texturearray[cnt] = GetFromSet( FLATLAND_TEXTURE, &world->textures );
texturearray[cnt]->iName = GetMemberIndex( NAME, &world->names, namearray[nName] );
sz += fread( &flag, 1, sizeof( flag ), pFile );
texturearray[cnt]->flags.bColor = flag;
if( flag )
{
sz += fread( &texturearray[cnt]->data.color, 1, sizeof(CDATA), pFile );
}
}
//for( cnt = 0; cnt < nsectors; cnt++ )
//{
// int ntexture = (int)sectorarray[cnt]->iTexture;
// sectorarray[cnt]->texture = NULL;
// SetTexture( sectorarray[cnt]->texture, texturearray[ntexture] );
//}
Release( texturearray );
}
Release( namearray );
}
if( version > 9 )
{
if( sz != size )
{
Log2( "Total load size %d is not %d", sz, size );
}
}
//for( cnt = 0; cnt < nsectors; cnt++ )
{
//PSECTOR pSector = sectorarray[cnt];
// again with the min/max fetch with
// spacetree add
//pSector->spacenode = AddSpaceNode( &world->spacetree, pSector, min, max );
}
Release( linearray );
Release( wallarray );
Release( sectorarray );
ValidateWorldLinks(iWorld);
return version;
}
