void plGenericType::CopyFrom(const plGenericType& c)
{
IDeallocString();
fType = c.fType;
if (fType==kString || fType==kAny)
{
fS=hsStrcpy(c.fS);
}
else
{
HSMemory::BlockMove((void*)&c.fI, (void*)&fI, 4);
}
}
void plVarDescriptor::CopyFrom(const plVarDescriptor* other)
{
SetName(other->GetName());
SetDefault(other->GetDefault());
SetCount(other->GetCount());
SetDisplayOptions(other->GetDisplayOptions());
delete [] fTypeString;
fTypeString=hsStrcpy(other->GetTypeString());
fType = other->GetType();
fFlags = other->fFlags;
}
void plAutoUIBase::AddFloatSpinner(int16_t id, const char *scriptName, const char *name, int vid, std::vector<std::string>* vstates, float def, float min, float max)
{
char *scriptNameNew = scriptName ? hsStrcpy(scriptName) : IMakeScriptName(name);
fDesc->AddParam(id, scriptNameNew, TYPE_FLOAT, 0, 0,
p_default, def,
p_range, min, max,
end,
end);
plAutoUIParam* param = new plSpinnerParam(id, name, true);
param->SetVisInfo(vid, vstates);
fParams.push_back(param);
}
bool ICallStrFunc(PyObject *dict, char *funcName, char*& val)
{
PyObject *obj;
if (ICallVoidFunc(dict, funcName, obj))
{
if (PyString_Check(obj))
{
val = hsStrcpy(PyString_AsString(obj));
Py_DECREF(obj);
return true;
}
}
return false;
}
void plSoundBuffer::SetFileName( const char *name )
{
if(fLoading)
{
hsAssert(false, "Unable to set SoundBuffer filename");
return;
}
delete [] fFileName;
if( name != nil )
fFileName = hsStrcpy( name );
else
fFileName = nil;
// Data is no longer valid
UnLoad();
}
plRegistryPageNode::plRegistryPageNode(const char* path)
: fValid(kPageCorrupt)
, fPath(nil)
, fDynLoadedTypes(0)
, fStaticLoadedTypes(0)
, fOpenRequests(0)
, fIsNewPage(false)
{
fPath = hsStrcpy(path);
hsStream* stream = OpenStream();
if (stream)
{
fPageInfo.Read(&fStream);
fValid = IVerify();
CloseStream();
}
}
bool pfConsoleContext::SetVar( uint32_t idx, const pfConsoleCmdParam &value )
{
hsAssert( fVarValues.GetCount() == fVarNames.GetCount(), "Mismatch in console var context arrays" );
if( idx >= fVarValues.GetCount() )
{
hsAssert( false, "SetVar() index out of range for console context" );
return false;
}
if( fVarValues[ idx ].GetType() == pfConsoleCmdParam::kString )
{
// Remember, params won't know any better, since by default they don't own a copy of their string
delete [] ( (char *)fVarValues[ idx ] );
}
fVarValues[ idx ] = value;
if( fVarValues[ idx ].GetType() == pfConsoleCmdParam::kString )
fVarValues[ idx ].SetString( hsStrcpy( fVarValues[ idx ] ) );
return true;
}
HFONT plWinFontCache::IMakeFont( const char *face, int height, int weight, bool italic, uint32_t quality )
{
plFontRecord myRec;
int i;
// Find a cached name for us
for( i = 0; i < fFontNameCache.GetCount(); i++ )
{
if( strcmp( face, fFontNameCache[ i ] ) == 0 )
break;
}
if( i == fFontNameCache.GetCount() )
fFontNameCache.Append( hsStrcpy( face ) );
myRec.fFace = fFontNameCache[ i ];
myRec.fHeight = height;
myRec.fWeight = weight;
myRec.fItalic = italic;
myRec.fQuality = quality;
myRec.fFont = CreateFont( height, 0, 0, 0, weight, italic ? TRUE : FALSE, FALSE, FALSE, ANSI_CHARSET, OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, VARIABLE_PITCH, face );
if( myRec.fFont != nil )
{
//#ifdef HS_DEBUGGING
#if 1
LOGFONT fontInfo;
if( GetObject( myRec.fFont, sizeof( fontInfo ), &fontInfo ) )
{
const char *err = nil;
if( fontInfo.lfQuality != quality )
err = "Quality of created font does not match";
if( fontInfo.lfHeight != height )
err = "Height of created font does not match";
if( fontInfo.lfWeight != weight )
err = "Weight of created font does not match";
if( static_cast<bool>(fontInfo.lfItalic) != italic )
err = "Italic-ness of created font does not match";
if( stricmp( fontInfo.lfFaceName, face ) != 0 )
err = "Face of created font does not match";
if( err != nil )
{
static bool triedClearing = false;
if( fontInfo.lfQuality != quality )
{
plStatusLog::AddLineS( "pipeline.log", "ERROR: CreateFont() failed to return proper font (%s). Using what was given...", err );
}
else
{
plStatusLog::AddLineS( "pipeline.log", "ERROR: CreateFont() failed to return proper font (%s). %s", err, triedClearing ? "" : "Clearing cache and retrying..." );
if( !triedClearing )
{
triedClearing = true;
// Didn't work, so get rid of it
DeleteObject( myRec.fFont );
// Clear all fonts and try again
Clear();
// Make sure we reload our custom fonts tho
ILoadCustomFonts();
// Try again
HFONT font = IMakeFont( face, height, weight, italic, quality );
triedClearing = false;
return font;
}
}
}
}
#endif
fFontCache.Append( myRec );
}
else
{
plStatusLog::AddLineS( "pipeline.log", "ERROR: CreateFont() call FAILED (face: %s, size: %d %s %s)", face, -height, weight == FW_BOLD ? "bold" : "", italic ? "italic" : "" );
}
return myRec.fFont;
}
hsFile::hsFile(const char pathAndName[]) : fPathAndName(nil), fFILE(nil)
{
if (pathAndName)
fPathAndName = hsStrcpy(pathAndName);
}
plTextureExportLog::plTextureExportLog( const char *fileName )
{
fFileName = hsStrcpy( fileName );
fNodeList = nil;
}
void plDynSurfaceWriter::plWinSurface::SetFont( const char *face, uint16_t size, uint8_t flags, hsBool aaRGB )
{
delete [] fFontFace;
fFontFace = ( face != nil ) ? hsStrcpy( face ) : nil;
fFontSize = size;
fFontFlags = flags;
fFontAntiAliasRGB = aaRGB;
bool hadAFont = false;
if( fFont != nil )
{
hadAFont = true;
plWinFontCache::GetInstance().FreeFont( fFont );
fFont = nil;
}
if( face == nil )
return;
bool bold = ( fFontFlags & plDynSurfaceWriter::kFontBold ) ? true : false;
bool italic = ( fFontFlags & plDynSurfaceWriter::kFontItalic ) ? true : false;
int nHeight = -MulDiv( size, GetDeviceCaps( fDC, LOGPIXELSY ), 72 );
fFont = plWinFontCache::GetInstance().GetMeAFont( face, nHeight, bold ? FW_BOLD : FW_NORMAL, italic,
fFontAntiAliasRGB ? ANTIALIASED_QUALITY : DEFAULT_QUALITY );
if( fFont == nil && fFontAntiAliasRGB )
{
static bool warnedCantAntiAlias = false;
// Creation of font failed; could be that we can't do anti-aliasing? Try not doing it...
if( !warnedCantAntiAlias )
{
plStatusLog::AddLineS( "pipeline.log", "WARNING: Cannot allocate anti-aliased font. Falling back to non-anti-aliased. This will be the only warning" );
warnedCantAntiAlias = true;
}
fFont = plWinFontCache::GetInstance().GetMeAFont( face, nHeight, bold ? FW_BOLD : FW_NORMAL, italic,
fFontAntiAliasRGB ? ANTIALIASED_QUALITY : DEFAULT_QUALITY );
}
if( fFont == nil )
{
hsAssert( false, "Cannot create Windows font for plDynSurfaceWriter" );
plStatusLog::AddLineS( "pipeline.log", "ERROR: Cannot allocate font for RGB surface! (face: %s, size: %d %s %s)", face, nHeight, bold ? "bold" : "", italic ? "italic" : "" );
delete [] fFontFace;
fFontFace = nil;
fFontSize = 0;
return;
}
if( SelectObject( fDC, fFont ) == nil && hadAFont )
{
char msg[ 256 ];
FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nil, GetLastError(), MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), msg, sizeof( msg ), nil );
char *ret = strrchr( msg, '\n' );
if( ret != nil )
*ret = 0;
plStatusLog::AddLineS( "pipeline.log", 0xffff0000, "SelectObject() FAILED (%s)", msg );
}
}
void plClothingTileset::SetName(char *name)
{
delete fName; fName = hsStrcpy(name);
}
pfConsoleContext::pfConsoleContext( const char *name )
{
fName = ( name != nil ) ? hsStrcpy( name ) : nil;
fAddWhenNotFound = true;
}
//
// Set type from a string. Return false on err.
//
bool plVarDescriptor::SetType(const char* type)
{
if (!type)
return false;
if (!stricmp(type, "vector3"))
fType=kVector3;
else
if (!stricmp(type, "point3"))
fType=kPoint3;
else
if (!stricmp(type, "rgb"))
fType=kRGB;
else
if (!stricmp(type, "rgba"))
fType=kRGBA;
else
if (!stricmp(type, "rgb8"))
fType=kRGB8;
else
if (!stricmp(type, "rgba8"))
fType=kRGBA8;
else
if (!strnicmp(type, "quat",4))
fType=kQuaternion;
else
if (!stricmp(type, "rgba"))
fType=kRGBA;
else
if (!stricmp(type, "int"))
fType=kInt;
else
if (!stricmp(type, "byte"))
fType=kByte;
else
if (!stricmp(type, "short"))
fType=kShort;
else
if (!stricmp(type, "float"))
fType=kFloat;
else
if (!stricmp(type, "double"))
fType=kDouble;
else
if (!stricmp(type, "time"))
fType=kTime;
else
if (!stricmp(type, "ageTimeOfDay"))
fType=kAgeTimeOfDay;
else
if (!stricmp(type, "bool"))
fType=kBool;
else
if (!stricmp(type, "string32"))
fType=kString32;
else
if (!stricmp(type, "plKey"))
fType=kKey;
else
if (!stricmp(type, "message") || !stricmp(type, "creatable") )
fType=kCreatable;
else
if (*type=='$')
fType=kStateDescriptor;
else
return false; // err
delete [] fTypeString;
fTypeString = hsStrcpy(type);
return true; // ok
}
void pfConsoleCmd::ICreateSignature(const char *paramList )
{
static char seps[] = " :-";
char params[ 256 ];
char *ptr, *nextPtr, *tok, *tok2;
int i;
/// Simple check
if( paramList == nil )
{
fSignature.Push( kAny );
fSigLabels.Push( (char *)nil );
return;
}
/// So we can do stuff to it
hsAssert( strlen( paramList ) < sizeof( params ), "Make the (#*$& params string larger!" );
hsStrcpy( params, paramList );
fSignature.Empty();
fSigLabels.Empty();
/// Loop through all the types given in the list
ptr = params;
do
{
/// Find break
nextPtr = strchr( ptr, ',' );
if( nextPtr != nil )
{
*nextPtr = 0;
nextPtr++;
}
/// Do this param
tok = strtok( ptr, seps );
if( tok == nil && ptr == params )
break;
hsAssert( tok != nil, "Bad parameter list for console command!" );
tok2 = strtok( nil, seps );
if( tok2 != nil )
{
// Type and label: assume label second
fSigLabels.Push( hsStrcpy( tok2 ) );
}
else
fSigLabels.Push( (char *)nil );
// Find type
for( i = 0; i < kNumTypes; i++ )
{
if( strcmp( fSigTypes[ i ], tok ) == 0 )
{
fSignature.Push( (uint8_t)i );
break;
}
}
hsAssert( i < kNumTypes, "Bad parameter type in console command parameter list!" );
} while( ( ptr = nextPtr ) != nil );
}
void plAgeGlobalAnim::SetGlobalVarName(char *name)
{
delete [] fGlobalVarName;
fGlobalVarName = hsStrcpy(name);
}
void plLayerMovie::SetMovieName(const char* n)
{
delete [] fMovieName;
fMovieName = hsStrcpy(n);
}
hsBool Open(const char* filename, const char* mode)
{
fFilename = hsStrcpy(filename);
return plZlibStream::Open(filename, mode);
}
void plLayerSDLAnimation::SetVarName(char *name)
{
delete [] fVarName;
fVarName = hsStrcpy(name);
}
