mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-23 21:02:11 +00:00
855 lines
18 KiB
C++
855 lines
18 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#ifndef __WINVAR_H__
|
|
#define __WINVAR_H__
|
|
|
|
#include "Rectangle.h"
|
|
|
|
static const char *VAR_GUIPREFIX = "gui::";
|
|
static const int VAR_GUIPREFIX_LEN = strlen(VAR_GUIPREFIX);
|
|
|
|
class idWindow;
|
|
class idWinVar {
|
|
public:
|
|
idWinVar();
|
|
virtual ~idWinVar();
|
|
|
|
void SetGuiInfo(idDict *gd, const char *_name);
|
|
const char *GetName() const {
|
|
if (name) {
|
|
if (guiDict && *name == '*') {
|
|
return guiDict->GetString(&name[1]);
|
|
}
|
|
return name;
|
|
}
|
|
return "";
|
|
}
|
|
void SetName(const char *_name) {
|
|
delete []name;
|
|
name = NULL;
|
|
if (_name) {
|
|
name = new char[strlen(_name)+1];
|
|
strcpy(name, _name);
|
|
}
|
|
}
|
|
|
|
idWinVar &operator=( const idWinVar &other ) {
|
|
guiDict = other.guiDict;
|
|
SetName(other.name);
|
|
return *this;
|
|
}
|
|
|
|
idDict *GetDict() const { return guiDict; }
|
|
bool NeedsUpdate() { return (guiDict != NULL); }
|
|
|
|
virtual void Init(const char *_name, idWindow* win) = 0;
|
|
virtual void Set(const char *val) = 0;
|
|
virtual void Update() = 0;
|
|
virtual const char *c_str() const = 0;
|
|
virtual size_t Size() { size_t sz = (name) ? strlen(name) : 0; return sz + sizeof(*this); }
|
|
|
|
virtual void WriteToSaveGame( idFile *savefile ) = 0;
|
|
virtual void ReadFromSaveGame( idFile *savefile ) = 0;
|
|
|
|
virtual float x( void ) const = 0;
|
|
|
|
void SetEval(bool b) {
|
|
eval = b;
|
|
}
|
|
bool GetEval() {
|
|
return eval;
|
|
}
|
|
|
|
protected:
|
|
idDict *guiDict;
|
|
char *name;
|
|
bool eval;
|
|
};
|
|
|
|
class idWinBool : public idWinVar {
|
|
public:
|
|
idWinBool() : idWinVar() {};
|
|
~idWinBool() {};
|
|
virtual void Init(const char *_name, idWindow *win) { idWinVar::Init(_name, win);
|
|
if (guiDict) {
|
|
data = guiDict->GetBool(GetName());
|
|
}
|
|
}
|
|
int operator==( const bool &other ) { return (other == data); }
|
|
bool &operator=( const bool &other ) {
|
|
data = other;
|
|
if (guiDict) {
|
|
guiDict->SetBool(GetName(), data);
|
|
}
|
|
return data;
|
|
}
|
|
idWinBool &operator=( const idWinBool &other ) {
|
|
idWinVar::operator=(other);
|
|
data = other.data;
|
|
return *this;
|
|
}
|
|
|
|
operator bool() const { return data; }
|
|
|
|
virtual void Set(const char *val) {
|
|
data = ( atoi( val ) != 0 );
|
|
if (guiDict) {
|
|
guiDict->SetBool(GetName(), data);
|
|
}
|
|
}
|
|
|
|
virtual void Update() {
|
|
const char *s = GetName();
|
|
if ( guiDict && s[0] != '\0' ) {
|
|
data = guiDict->GetBool( s );
|
|
}
|
|
}
|
|
|
|
virtual const char *c_str() const {return va("%i", data); }
|
|
|
|
// SaveGames
|
|
virtual void WriteToSaveGame( idFile *savefile ) {
|
|
savefile->Write( &eval, sizeof( eval ) );
|
|
savefile->Write( &data, sizeof( data ) );
|
|
}
|
|
virtual void ReadFromSaveGame( idFile *savefile ) {
|
|
savefile->Read( &eval, sizeof( eval ) );
|
|
savefile->Read( &data, sizeof( data ) );
|
|
}
|
|
|
|
virtual float x( void ) const { return data ? 1.0f : 0.0f; };
|
|
|
|
protected:
|
|
bool data;
|
|
};
|
|
|
|
class idWinStr : public idWinVar {
|
|
public:
|
|
idWinStr() : idWinVar() {};
|
|
~idWinStr() {};
|
|
virtual void Init(const char *_name, idWindow *win) {
|
|
idWinVar::Init(_name, win);
|
|
if (guiDict) {
|
|
data = guiDict->GetString(GetName());
|
|
}
|
|
}
|
|
int operator==( const idStr &other ) const {
|
|
return (other == data);
|
|
}
|
|
int operator==( const char *other ) const {
|
|
return (data == other);
|
|
}
|
|
idStr &operator=( const idStr &other ) {
|
|
data = other;
|
|
if (guiDict) {
|
|
guiDict->Set(GetName(), data);
|
|
}
|
|
return data;
|
|
}
|
|
idWinStr &operator=( const idWinStr &other ) {
|
|
idWinVar::operator=(other);
|
|
data = other.data;
|
|
return *this;
|
|
}
|
|
operator const char *() const {
|
|
return data.c_str();
|
|
}
|
|
operator const idStr &() const {
|
|
return data;
|
|
}
|
|
int LengthWithoutColors() {
|
|
if (guiDict && name && *name) {
|
|
data = guiDict->GetString(GetName());
|
|
}
|
|
return data.LengthWithoutColors();
|
|
}
|
|
int Length() {
|
|
if (guiDict && name && *name) {
|
|
data = guiDict->GetString(GetName());
|
|
}
|
|
return data.Length();
|
|
}
|
|
void RemoveColors() {
|
|
if (guiDict && name && *name) {
|
|
data = guiDict->GetString(GetName());
|
|
}
|
|
data.RemoveColors();
|
|
}
|
|
virtual const char *c_str() const {
|
|
return data.c_str();
|
|
}
|
|
|
|
virtual void Set(const char *val) {
|
|
data = val;
|
|
if ( guiDict ) {
|
|
guiDict->Set(GetName(), data);
|
|
}
|
|
}
|
|
|
|
virtual void Update() {
|
|
const char *s = GetName();
|
|
if ( guiDict && s[0] != '\0' ) {
|
|
data = guiDict->GetString( s );
|
|
}
|
|
}
|
|
|
|
virtual size_t Size() {
|
|
size_t sz = idWinVar::Size();
|
|
return sz +data.Allocated();
|
|
}
|
|
|
|
// SaveGames
|
|
virtual void WriteToSaveGame( idFile *savefile ) {
|
|
savefile->Write( &eval, sizeof( eval ) );
|
|
|
|
int len = data.Length();
|
|
savefile->Write( &len, sizeof( len ) );
|
|
if ( len > 0 ) {
|
|
savefile->Write( data.c_str(), len );
|
|
}
|
|
}
|
|
virtual void ReadFromSaveGame( idFile *savefile ) {
|
|
savefile->Read( &eval, sizeof( eval ) );
|
|
|
|
int len;
|
|
savefile->Read( &len, sizeof( len ) );
|
|
if ( len > 0 ) {
|
|
data.Fill( ' ', len );
|
|
savefile->Read( &data[0], len );
|
|
}
|
|
}
|
|
|
|
// return wether string is emtpy
|
|
virtual float x( void ) const { return data[0] ? 1.0f : 0.0f; };
|
|
|
|
protected:
|
|
idStr data;
|
|
};
|
|
|
|
class idWinInt : public idWinVar {
|
|
public:
|
|
idWinInt() : idWinVar() {};
|
|
~idWinInt() {};
|
|
virtual void Init(const char *_name, idWindow *win) {
|
|
idWinVar::Init(_name, win);
|
|
if (guiDict) {
|
|
data = guiDict->GetInt(GetName());
|
|
}
|
|
}
|
|
int &operator=( const int &other ) {
|
|
data = other;
|
|
if (guiDict) {
|
|
guiDict->SetInt(GetName(), data);
|
|
}
|
|
return data;
|
|
}
|
|
idWinInt &operator=( const idWinInt &other ) {
|
|
idWinVar::operator=(other);
|
|
data = other.data;
|
|
return *this;
|
|
}
|
|
operator int () const {
|
|
return data;
|
|
}
|
|
virtual void Set(const char *val) {
|
|
data = atoi(val);;
|
|
if (guiDict) {
|
|
guiDict->SetInt(GetName(), data);
|
|
}
|
|
}
|
|
|
|
virtual void Update() {
|
|
const char *s = GetName();
|
|
if ( guiDict && s[0] != '\0' ) {
|
|
data = guiDict->GetInt( s );
|
|
}
|
|
}
|
|
virtual const char *c_str() const {
|
|
return va("%i", data);
|
|
}
|
|
|
|
// SaveGames
|
|
virtual void WriteToSaveGame( idFile *savefile ) {
|
|
savefile->Write( &eval, sizeof( eval ) );
|
|
savefile->Write( &data, sizeof( data ) );
|
|
}
|
|
virtual void ReadFromSaveGame( idFile *savefile ) {
|
|
savefile->Read( &eval, sizeof( eval ) );
|
|
savefile->Read( &data, sizeof( data ) );
|
|
}
|
|
|
|
// no suitable conversion
|
|
virtual float x( void ) const { assert( false ); return 0.0f; };
|
|
|
|
protected:
|
|
int data;
|
|
};
|
|
|
|
class idWinFloat : public idWinVar {
|
|
public:
|
|
idWinFloat() : idWinVar() {};
|
|
~idWinFloat() {};
|
|
virtual void Init(const char *_name, idWindow *win) {
|
|
idWinVar::Init(_name, win);
|
|
if (guiDict) {
|
|
data = guiDict->GetFloat(GetName());
|
|
}
|
|
}
|
|
idWinFloat &operator=( const idWinFloat &other ) {
|
|
idWinVar::operator=(other);
|
|
data = other.data;
|
|
return *this;
|
|
}
|
|
float &operator=( const float &other ) {
|
|
data = other;
|
|
if (guiDict) {
|
|
guiDict->SetFloat(GetName(), data);
|
|
}
|
|
return data;
|
|
}
|
|
operator float() const {
|
|
return data;
|
|
}
|
|
virtual void Set(const char *val) {
|
|
data = atof(val);
|
|
if (guiDict) {
|
|
guiDict->SetFloat(GetName(), data);
|
|
}
|
|
}
|
|
virtual void Update() {
|
|
const char *s = GetName();
|
|
if ( guiDict && s[0] != '\0' ) {
|
|
data = guiDict->GetFloat( s );
|
|
}
|
|
}
|
|
virtual const char *c_str() const {
|
|
return va("%f", data);
|
|
}
|
|
|
|
virtual void WriteToSaveGame( idFile *savefile ) {
|
|
savefile->Write( &eval, sizeof( eval ) );
|
|
savefile->Write( &data, sizeof( data ) );
|
|
}
|
|
virtual void ReadFromSaveGame( idFile *savefile ) {
|
|
savefile->Read( &eval, sizeof( eval ) );
|
|
savefile->Read( &data, sizeof( data ) );
|
|
}
|
|
|
|
virtual float x( void ) const { return data; };
|
|
protected:
|
|
float data;
|
|
};
|
|
|
|
class idWinRectangle : public idWinVar {
|
|
public:
|
|
idWinRectangle() : idWinVar() {};
|
|
~idWinRectangle() {};
|
|
virtual void Init(const char *_name, idWindow *win) {
|
|
idWinVar::Init(_name, win);
|
|
if (guiDict) {
|
|
idVec4 v = guiDict->GetVec4(GetName());
|
|
data.x = v.x;
|
|
data.y = v.y;
|
|
data.w = v.z;
|
|
data.h = v.w;
|
|
}
|
|
}
|
|
|
|
int operator==( const idRectangle &other ) const {
|
|
return (other == data);
|
|
}
|
|
|
|
idWinRectangle &operator=( const idWinRectangle &other ) {
|
|
idWinVar::operator=(other);
|
|
data = other.data;
|
|
return *this;
|
|
}
|
|
idRectangle &operator=( const idVec4 &other ) {
|
|
data = other;
|
|
if (guiDict) {
|
|
guiDict->SetVec4(GetName(), other);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
idRectangle &operator=( const idRectangle &other ) {
|
|
data = other;
|
|
if (guiDict) {
|
|
idVec4 v = data.ToVec4();
|
|
guiDict->SetVec4(GetName(), v);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
operator const idRectangle&() const {
|
|
return data;
|
|
}
|
|
|
|
float x() const {
|
|
return data.x;
|
|
}
|
|
float y() const {
|
|
return data.y;
|
|
}
|
|
float w() const {
|
|
return data.w;
|
|
}
|
|
float h() const {
|
|
return data.h;
|
|
}
|
|
float Right() const {
|
|
return data.Right();
|
|
}
|
|
float Bottom() const {
|
|
return data.Bottom();
|
|
}
|
|
idVec4 &ToVec4() {
|
|
static idVec4 ret;
|
|
ret = data.ToVec4();
|
|
return ret;
|
|
}
|
|
virtual void Set(const char *val) {
|
|
if ( strchr ( val, ',' ) ) {
|
|
sscanf( val, "%f,%f,%f,%f", &data.x, &data.y, &data.w, &data.h );
|
|
} else {
|
|
sscanf( val, "%f %f %f %f", &data.x, &data.y, &data.w, &data.h );
|
|
}
|
|
if (guiDict) {
|
|
idVec4 v = data.ToVec4();
|
|
guiDict->SetVec4(GetName(), v);
|
|
}
|
|
}
|
|
virtual void Update() {
|
|
const char *s = GetName();
|
|
if ( guiDict && s[0] != '\0' ) {
|
|
idVec4 v = guiDict->GetVec4( s );
|
|
data.x = v.x;
|
|
data.y = v.y;
|
|
data.w = v.z;
|
|
data.h = v.w;
|
|
}
|
|
}
|
|
|
|
virtual const char *c_str() const {
|
|
return data.ToVec4().ToString();
|
|
}
|
|
|
|
virtual void WriteToSaveGame( idFile *savefile ) {
|
|
savefile->Write( &eval, sizeof( eval ) );
|
|
savefile->Write( &data, sizeof( data ) );
|
|
}
|
|
virtual void ReadFromSaveGame( idFile *savefile ) {
|
|
savefile->Read( &eval, sizeof( eval ) );
|
|
savefile->Read( &data, sizeof( data ) );
|
|
}
|
|
|
|
protected:
|
|
idRectangle data;
|
|
};
|
|
|
|
class idWinVec2 : public idWinVar {
|
|
public:
|
|
idWinVec2() : idWinVar() {};
|
|
~idWinVec2() {};
|
|
virtual void Init(const char *_name, idWindow *win) {
|
|
idWinVar::Init(_name, win);
|
|
if (guiDict) {
|
|
data = guiDict->GetVec2(GetName());
|
|
}
|
|
}
|
|
int operator==( const idVec2 &other ) const {
|
|
return (other == data);
|
|
}
|
|
idWinVec2 &operator=( const idWinVec2 &other ) {
|
|
idWinVar::operator=(other);
|
|
data = other.data;
|
|
return *this;
|
|
}
|
|
|
|
idVec2 &operator=( const idVec2 &other ) {
|
|
data = other;
|
|
if (guiDict) {
|
|
guiDict->SetVec2(GetName(), data);
|
|
}
|
|
return data;
|
|
}
|
|
float x() const {
|
|
return data.x;
|
|
}
|
|
float y() const {
|
|
return data.y;
|
|
}
|
|
virtual void Set(const char *val) {
|
|
if ( strchr ( val, ',' ) ) {
|
|
sscanf( val, "%f,%f", &data.x, &data.y );
|
|
} else {
|
|
sscanf( val, "%f %f", &data.x, &data.y);
|
|
}
|
|
if (guiDict) {
|
|
guiDict->SetVec2(GetName(), data);
|
|
}
|
|
}
|
|
operator const idVec2&() const {
|
|
return data;
|
|
}
|
|
virtual void Update() {
|
|
const char *s = GetName();
|
|
if ( guiDict && s[0] != '\0' ) {
|
|
data = guiDict->GetVec2( s );
|
|
}
|
|
}
|
|
virtual const char *c_str() const {
|
|
return data.ToString();
|
|
}
|
|
void Zero() {
|
|
data.Zero();
|
|
}
|
|
|
|
virtual void WriteToSaveGame( idFile *savefile ) {
|
|
savefile->Write( &eval, sizeof( eval ) );
|
|
savefile->Write( &data, sizeof( data ) );
|
|
}
|
|
virtual void ReadFromSaveGame( idFile *savefile ) {
|
|
savefile->Read( &eval, sizeof( eval ) );
|
|
savefile->Read( &data, sizeof( data ) );
|
|
}
|
|
|
|
protected:
|
|
idVec2 data;
|
|
};
|
|
|
|
class idWinVec4 : public idWinVar {
|
|
public:
|
|
idWinVec4() : idWinVar() {};
|
|
~idWinVec4() {};
|
|
virtual void Init(const char *_name, idWindow *win) {
|
|
idWinVar::Init(_name, win);
|
|
if (guiDict) {
|
|
data = guiDict->GetVec4(GetName());
|
|
}
|
|
}
|
|
int operator==( const idVec4 &other ) const {
|
|
return (other == data);
|
|
}
|
|
idWinVec4 &operator=( const idWinVec4 &other ) {
|
|
idWinVar::operator=(other);
|
|
data = other.data;
|
|
return *this;
|
|
}
|
|
idVec4 &operator=( const idVec4 &other ) {
|
|
data = other;
|
|
if (guiDict) {
|
|
guiDict->SetVec4(GetName(), data);
|
|
}
|
|
return data;
|
|
}
|
|
operator const idVec4&() const {
|
|
return data;
|
|
}
|
|
|
|
float x() const {
|
|
return data.x;
|
|
}
|
|
|
|
float y() const {
|
|
return data.y;
|
|
}
|
|
|
|
float z() const {
|
|
return data.z;
|
|
}
|
|
|
|
float w() const {
|
|
return data.w;
|
|
}
|
|
virtual void Set(const char *val) {
|
|
if ( strchr ( val, ',' ) ) {
|
|
sscanf( val, "%f,%f,%f,%f", &data.x, &data.y, &data.z, &data.w );
|
|
} else {
|
|
sscanf( val, "%f %f %f %f", &data.x, &data.y, &data.z, &data.w);
|
|
}
|
|
if ( guiDict ) {
|
|
guiDict->SetVec4( GetName(), data );
|
|
}
|
|
}
|
|
virtual void Update() {
|
|
const char *s = GetName();
|
|
if ( guiDict && s[0] != '\0' ) {
|
|
data = guiDict->GetVec4( s );
|
|
}
|
|
}
|
|
virtual const char *c_str() const {
|
|
return data.ToString();
|
|
}
|
|
|
|
void Zero() {
|
|
data.Zero();
|
|
if ( guiDict ) {
|
|
guiDict->SetVec4(GetName(), data);
|
|
}
|
|
}
|
|
|
|
const idVec3 &ToVec3() const {
|
|
return data.ToVec3();
|
|
}
|
|
|
|
virtual void WriteToSaveGame( idFile *savefile ) {
|
|
savefile->Write( &eval, sizeof( eval ) );
|
|
savefile->Write( &data, sizeof( data ) );
|
|
}
|
|
virtual void ReadFromSaveGame( idFile *savefile ) {
|
|
savefile->Read( &eval, sizeof( eval ) );
|
|
savefile->Read( &data, sizeof( data ) );
|
|
}
|
|
|
|
protected:
|
|
idVec4 data;
|
|
};
|
|
|
|
class idWinVec3 : public idWinVar {
|
|
public:
|
|
idWinVec3() : idWinVar() {};
|
|
~idWinVec3() {};
|
|
virtual void Init(const char *_name, idWindow *win) {
|
|
idWinVar::Init(_name, win);
|
|
if (guiDict) {
|
|
data = guiDict->GetVector(GetName());
|
|
}
|
|
}
|
|
int operator==( const idVec3 &other ) const {
|
|
return (other == data);
|
|
}
|
|
idWinVec3 &operator=( const idWinVec3 &other ) {
|
|
idWinVar::operator=(other);
|
|
data = other.data;
|
|
return *this;
|
|
}
|
|
idVec3 &operator=( const idVec3 &other ) {
|
|
data = other;
|
|
if (guiDict) {
|
|
guiDict->SetVector(GetName(), data);
|
|
}
|
|
return data;
|
|
}
|
|
operator const idVec3&() const {
|
|
return data;
|
|
}
|
|
|
|
float x() const {
|
|
return data.x;
|
|
}
|
|
|
|
float y() const {
|
|
return data.y;
|
|
}
|
|
|
|
float z() const {
|
|
return data.z;
|
|
}
|
|
|
|
virtual void Set(const char *val) {
|
|
sscanf( val, "%f %f %f", &data.x, &data.y, &data.z);
|
|
if (guiDict) {
|
|
guiDict->SetVector(GetName(), data);
|
|
}
|
|
}
|
|
virtual void Update() {
|
|
const char *s = GetName();
|
|
if ( guiDict && s[0] != '\0' ) {
|
|
data = guiDict->GetVector( s );
|
|
}
|
|
}
|
|
virtual const char *c_str() const {
|
|
return data.ToString();
|
|
}
|
|
|
|
void Zero() {
|
|
data.Zero();
|
|
if (guiDict) {
|
|
guiDict->SetVector(GetName(), data);
|
|
}
|
|
}
|
|
|
|
virtual void WriteToSaveGame( idFile *savefile ) {
|
|
savefile->Write( &eval, sizeof( eval ) );
|
|
savefile->Write( &data, sizeof( data ) );
|
|
}
|
|
virtual void ReadFromSaveGame( idFile *savefile ) {
|
|
savefile->Read( &eval, sizeof( eval ) );
|
|
savefile->Read( &data, sizeof( data ) );
|
|
}
|
|
|
|
protected:
|
|
idVec3 data;
|
|
};
|
|
|
|
class idWinBackground : public idWinStr {
|
|
public:
|
|
idWinBackground() : idWinStr() {
|
|
mat = NULL;
|
|
};
|
|
~idWinBackground() {};
|
|
virtual void Init(const char *_name, idWindow *win) {
|
|
idWinStr::Init(_name, win);
|
|
if (guiDict) {
|
|
data = guiDict->GetString(GetName());
|
|
}
|
|
}
|
|
int operator==( const idStr &other ) const {
|
|
return (other == data);
|
|
}
|
|
int operator==( const char *other ) const {
|
|
return (data == other);
|
|
}
|
|
idStr &operator=( const idStr &other ) {
|
|
data = other;
|
|
if (guiDict) {
|
|
guiDict->Set(GetName(), data);
|
|
}
|
|
if (mat) {
|
|
if ( data == "" ) {
|
|
(*mat) = NULL;
|
|
} else {
|
|
(*mat) = declManager->FindMaterial(data);
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
idWinBackground &operator=( const idWinBackground &other ) {
|
|
idWinVar::operator=(other);
|
|
data = other.data;
|
|
mat = other.mat;
|
|
if (mat) {
|
|
if ( data == "" ) {
|
|
(*mat) = NULL;
|
|
} else {
|
|
(*mat) = declManager->FindMaterial(data);
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
operator const char *() const {
|
|
return data.c_str();
|
|
}
|
|
operator const idStr &() const {
|
|
return data;
|
|
}
|
|
int Length() {
|
|
if (guiDict) {
|
|
data = guiDict->GetString(GetName());
|
|
}
|
|
return data.Length();
|
|
}
|
|
virtual const char *c_str() const {
|
|
return data.c_str();
|
|
}
|
|
|
|
virtual void Set(const char *val) {
|
|
data = val;
|
|
if (guiDict) {
|
|
guiDict->Set(GetName(), data);
|
|
}
|
|
if (mat) {
|
|
if ( data == "" ) {
|
|
(*mat) = NULL;
|
|
} else {
|
|
(*mat) = declManager->FindMaterial(data);
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void Update() {
|
|
const char *s = GetName();
|
|
if ( guiDict && s[0] != '\0' ) {
|
|
data = guiDict->GetString( s );
|
|
if (mat) {
|
|
if ( data == "" ) {
|
|
(*mat) = NULL;
|
|
} else {
|
|
(*mat) = declManager->FindMaterial(data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual size_t Size() {
|
|
size_t sz = idWinVar::Size();
|
|
return sz +data.Allocated();
|
|
}
|
|
|
|
void SetMaterialPtr( const idMaterial **m ) {
|
|
mat = m;
|
|
}
|
|
|
|
virtual void WriteToSaveGame( idFile *savefile ) {
|
|
savefile->Write( &eval, sizeof( eval ) );
|
|
|
|
int len = data.Length();
|
|
savefile->Write( &len, sizeof( len ) );
|
|
if ( len > 0 ) {
|
|
savefile->Write( data.c_str(), len );
|
|
}
|
|
}
|
|
virtual void ReadFromSaveGame( idFile *savefile ) {
|
|
savefile->Read( &eval, sizeof( eval ) );
|
|
|
|
int len;
|
|
savefile->Read( &len, sizeof( len ) );
|
|
if ( len > 0 ) {
|
|
data.Fill( ' ', len );
|
|
savefile->Read( &data[0], len );
|
|
}
|
|
if ( mat ) {
|
|
if ( len > 0 ) {
|
|
(*mat) = declManager->FindMaterial( data );
|
|
} else {
|
|
(*mat) = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected:
|
|
idStr data;
|
|
const idMaterial **mat;
|
|
};
|
|
|
|
/*
|
|
================
|
|
idMultiWinVar
|
|
multiplexes access to a list if idWinVar*
|
|
================
|
|
*/
|
|
class idMultiWinVar : public idList< idWinVar * > {
|
|
public:
|
|
void Set( const char *val );
|
|
void Update( void );
|
|
void SetGuiInfo( idDict *dict );
|
|
};
|
|
|
|
#endif /* !__WINVAR_H__ */
|