d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
471 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 1ccbe2bbb6
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '1ccbe2bbb6'
${ noResults }
source-engine/public/tier1/ilocalize.h

504 lines
18 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#ifndef TIER1_ILOCALIZE_H
#define TIER1_ILOCALIZE_H
#ifdef _WIN32
#pragma once
#endif
#include "appframework/IAppSystem.h"
#include <tier1/KeyValues.h>
// unicode character type
// for more unicode manipulation functions #include <wchar.h>
#if !defined(_WCHAR_T_DEFINED) && !defined(GNUC)
typedef unsigned short wchar_t;
#define _WCHAR_T_DEFINED
#endif
// direct references to localized strings
typedef unsigned long StringIndex_t;
const unsigned long INVALID_LOCALIZE_STRING_INDEX = (StringIndex_t) -1;
//-----------------------------------------------------------------------------
// Purpose: Handles localization of text
// looks up string names and returns the localized unicode text
//-----------------------------------------------------------------------------
abstract_class ILocalize
{
public:
// adds the contents of a file to the localization table
virtual bool AddFile( const char *fileName, const char *pPathID = NULL, bool bIncludeFallbackSearchPaths = false ) = 0;
// Remove all strings from the table
virtual void RemoveAll() = 0;
// Finds the localized text for tokenName
virtual wchar_t *Find(char const *tokenName) = 0;
// finds the index of a token by token name, INVALID_STRING_INDEX if not found
virtual StringIndex_t FindIndex(const char *tokenName) = 0;
// gets the values by the string index
virtual const char *GetNameByIndex(StringIndex_t index) = 0;
virtual wchar_t *GetValueByIndex(StringIndex_t index) = 0;
///////////////////////////////////////////////////////////////////
// the following functions should only be used by localization editors
// iteration functions
virtual StringIndex_t GetFirstStringIndex() = 0;
// returns the next index, or INVALID_STRING_INDEX if no more strings available
virtual StringIndex_t GetNextStringIndex(StringIndex_t index) = 0;
// adds a single name/unicode string pair to the table
virtual void AddString( const char *tokenName, wchar_t *unicodeString, const char *fileName ) = 0;
// changes the value of a string
virtual void SetValueByIndex(StringIndex_t index, wchar_t *newValue) = 0;
// saves the entire contents of the token tree to the file
virtual bool SaveToFile( const char *fileName ) = 0;
// iterates the filenames
virtual int GetLocalizationFileCount() = 0;
virtual const char *GetLocalizationFileName(int index) = 0;
// returns the name of the file the specified localized string is stored in
virtual const char *GetFileNameByIndex(StringIndex_t index) = 0;
// for development only, reloads localization files
virtual void ReloadLocalizationFiles( ) = 0;
virtual const char *FindAsUTF8( const char *pchTokenName ) = 0;
// need to replace the existing ConstructString with this
virtual void ConstructString(OUT_Z_BYTECAP(unicodeBufferSizeInBytes) wchar_t *unicodeOutput, int unicodeBufferSizeInBytes, const char *tokenName, KeyValues *localizationVariables) = 0;
virtual void ConstructString(OUT_Z_BYTECAP(unicodeBufferSizeInBytes) wchar_t *unicodeOutput, int unicodeBufferSizeInBytes, StringIndex_t unlocalizedTextSymbol, KeyValues *localizationVariables) = 0;
///////////////////////////////////////////////////////////////////
// static interface
// converts an english string to unicode
// returns the number of wchar_t in resulting string, including null terminator
static int ConvertANSIToUnicode(const char *ansi, OUT_Z_BYTECAP(unicodeBufferSizeInBytes) wchar_t *unicode, int unicodeBufferSizeInBytes);
// converts an unicode string to an english string
// unrepresentable characters are converted to system default
// returns the number of characters in resulting string, including null terminator
static int ConvertUnicodeToANSI(const wchar_t *unicode, OUT_Z_BYTECAP(ansiBufferSize) char *ansi, int ansiBufferSize);
// builds a localized formatted string
// uses the format strings first: %s1, %s2, ... unicode strings (wchar_t *)
template < typename T >
static void ConstructString(OUT_Z_BYTECAP(unicodeBufferSizeInBytes) T *unicodeOuput, int unicodeBufferSizeInBytes, const T *formatString, int numFormatParameters, ...)
{
va_list argList;
va_start( argList, numFormatParameters );
ConstructStringVArgsInternal( unicodeOuput, unicodeBufferSizeInBytes, formatString, numFormatParameters, argList );
va_end( argList );
}
template < typename T >
static void ConstructStringVArgs(OUT_Z_BYTECAP(unicodeBufferSizeInBytes) T *unicodeOuput, int unicodeBufferSizeInBytes, const T *formatString, int numFormatParameters, va_list argList)
{
ConstructStringVArgsInternal( unicodeOuput, unicodeBufferSizeInBytes, formatString, numFormatParameters, argList );
}
template < typename T >
static void ConstructString(OUT_Z_BYTECAP(unicodeBufferSizeInBytes) T *unicodeOutput, int unicodeBufferSizeInBytes, const T *formatString, KeyValues *localizationVariables)
{
ConstructStringKeyValuesInternal( unicodeOutput, unicodeBufferSizeInBytes, formatString, localizationVariables );
}
// Safe version of Construct String that has the compiler infer the buffer size
template <size_t maxLenInChars, typename T >
static void ConstructString_safe( OUT_Z_ARRAY T (&pDest)[maxLenInChars], const T *formatString, int numFormatParameters, ... )
{
va_list argList;
va_start( argList, numFormatParameters );
ConstructStringVArgsInternal( pDest, maxLenInChars * sizeof( *pDest ), formatString, numFormatParameters, argList );
va_end( argList );
}
template <size_t maxLenInChars, typename T >
static void ConstructString_safe( OUT_Z_ARRAY T (&pDest)[maxLenInChars], const T *formatString, KeyValues *localizationVariables )
{
ConstructStringKeyValuesInternal( pDest, maxLenInChars * sizeof( *pDest ), formatString, localizationVariables );
}
// Non-static version to be safe version of the virtual functions that utilize KVP
template <size_t maxLenInChars, typename T >
void ConstructString_safe( OUT_Z_ARRAY T( &pDest )[maxLenInChars], const char *formatString, KeyValues *localizationVariables )
{
ConstructString( pDest, maxLenInChars * sizeof( *pDest ), formatString, localizationVariables );
}
private:
// internal "interface"
static void ConstructStringVArgsInternal(OUT_Z_BYTECAP(unicodeBufferSizeInBytes) char *unicodeOutput, int unicodeBufferSizeInBytes, const char *formatString, int numFormatParameters, va_list argList);
static void ConstructStringVArgsInternal(OUT_Z_BYTECAP(unicodeBufferSizeInBytes) wchar_t *unicodeOutput, int unicodeBufferSizeInBytes, const wchar_t *formatString, int numFormatParameters, va_list argList);
static void ConstructStringKeyValuesInternal(OUT_Z_BYTECAP(unicodeBufferSizeInBytes) char *unicodeOutput, int unicodeBufferSizeInBytes, const char *formatString, KeyValues *localizationVariables);
static void ConstructStringKeyValuesInternal(OUT_Z_BYTECAP(unicodeBufferSizeInBytes) wchar_t *unicodeOutput, int unicodeBufferSizeInBytes, const wchar_t *formatString, KeyValues *localizationVariables);
};
#ifdef GC
typedef char locchar_t;
#define loc_snprintf Q_snprintf
#define loc_sprintf_safe V_sprintf_safe
#define loc_sncat Q_strncat
#define loc_scat_safe V_strcat_safe
#define loc_sncpy Q_strncpy
#define loc_scpy_safe V_strcpy_safe
#define loc_strlen Q_strlen
#define LOCCHAR( x ) x
#else
typedef wchar_t locchar_t;
#define loc_snprintf V_snwprintf
#define loc_sprintf_safe V_swprintf_safe
#define loc_sncat V_wcsncat
#define loc_scat_safe V_wcscat_safe
#define loc_sncpy Q_wcsncpy
#define loc_scpy_safe V_wcscpy_safe
#define loc_strlen Q_wcslen
#define LOCCHAR(x) L ## x
#endif
// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
template < typename T >
class TypedKeyValuesStringHelper
{
public:
static const T *Read( KeyValues *pKeyValues, const char *pKeyName, const T *pDefaultValue );
static void Write( KeyValues *pKeyValues, const char *pKeyName, const T *pValue );
};
// --------------------------------------------------------------------------
template < >
class TypedKeyValuesStringHelper<char>
{
public:
static const char *Read( KeyValues *pKeyValues, const char *pKeyName, const char *pDefaultValue ) { return pKeyValues->GetString( pKeyName, pDefaultValue ); }
static void Write( KeyValues *pKeyValues, const char *pKeyName, const char *pValue ) { pKeyValues->SetString( pKeyName, pValue ); }
};
// --------------------------------------------------------------------------
template < >
class TypedKeyValuesStringHelper<wchar_t>
{
public:
static const wchar_t *Read( KeyValues *pKeyValues, const char *pKeyName, const wchar_t *pDefaultValue ) { return pKeyValues->GetWString( pKeyName, pDefaultValue ); }
static void Write( KeyValues *pKeyValues, const char *pKeyName, const wchar_t *pValue ) { pKeyValues->SetWString( pKeyName, pValue ); }
};
// --------------------------------------------------------------------------
// Purpose: CLocalizedStringArg<> is a class that will take a variable of any
// arbitary type and convert it to a string of whatever character type
// we're using for localization (locchar_t).
//
// Independently it isn't very useful, though it can be used to sort-of-
// intelligently fill out the correct format string. It's designed to be
// used for the arguments of CConstructLocalizedString, which can be of
// arbitrary number and type.
//
// If you pass in a (non-specialized) pointer, the code will assume that
// you meant that pointer to be used as a localized string. This will
// still fail to compile if some non-string type is passed in, but will
// handle weird combinations of const/volatile/whatever automatically.
// --------------------------------------------------------------------------
// The base implementation doesn't do anything except fail to compile if you
// use it. Getting an "incomplete type" error here means that you tried to construct
// a localized string with a type that doesn't have a specialization.
template < typename T >
class CLocalizedStringArg;
// --------------------------------------------------------------------------
template < typename T >
class CLocalizedStringArgStringImpl
{
public:
enum { kIsValid = true };
CLocalizedStringArgStringImpl( const locchar_t *pStr ) : m_pStr( pStr ) { }
const locchar_t *GetLocArg() const { Assert( m_pStr ); return m_pStr; }
private:
const locchar_t *m_pStr;
};
// --------------------------------------------------------------------------
template < typename T >
class CLocalizedStringArg<T *> : public CLocalizedStringArgStringImpl<T>
{
public:
CLocalizedStringArg( const locchar_t *pStr ) : CLocalizedStringArgStringImpl<T>( pStr ) { }
};
// --------------------------------------------------------------------------
template < typename T >
class CLocalizedStringArgPrintfImpl
{
public:
enum { kIsValid = true };
CLocalizedStringArgPrintfImpl( T value, const locchar_t *loc_Format ) { loc_snprintf( m_cBuffer, kBufferSize, loc_Format, value ); }
const locchar_t *GetLocArg() const { return m_cBuffer; }
private:
enum { kBufferSize = 128, };
locchar_t m_cBuffer[ kBufferSize ];
};
// --------------------------------------------------------------------------
template < >
class CLocalizedStringArg<uint16> : public CLocalizedStringArgPrintfImpl<uint16>
{
public:
CLocalizedStringArg( uint16 unValue ) : CLocalizedStringArgPrintfImpl<uint16>( unValue, LOCCHAR("%u") ) { }
};
// --------------------------------------------------------------------------
template < >
class CLocalizedStringArg<uint32> : public CLocalizedStringArgPrintfImpl<uint32>
{
public:
CLocalizedStringArg( uint32 unValue ) : CLocalizedStringArgPrintfImpl<uint32>( unValue, LOCCHAR("%u") ) { }
};
// --------------------------------------------------------------------------
template < >
class CLocalizedStringArg<uint64> : public CLocalizedStringArgPrintfImpl<uint64>
{
public:
CLocalizedStringArg( uint64 unValue ) : CLocalizedStringArgPrintfImpl<uint64>( unValue, LOCCHAR("%llu") ) { }
};
// --------------------------------------------------------------------------
template < >
class CLocalizedStringArg<float> : public CLocalizedStringArgPrintfImpl<float>
{
public:
// Display one decimal point if we've got a value less than one, and no point
// if we're greater than one or are effectively zero.
CLocalizedStringArg( float fValue )
: CLocalizedStringArgPrintfImpl<float>( fValue,
fabsf( fValue ) <= FLT_EPSILON || fabsf( fValue ) >= 1.0f ? LOCCHAR("%.0f") : LOCCHAR("%.1f") )
{
//
}
};
// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
class CConstructLocalizedString
{
public:
template < typename T >
CConstructLocalizedString( const locchar_t *loc_Format, T arg0 )
{
COMPILE_TIME_ASSERT( CLocalizedStringArg<T>::kIsValid );
m_loc_Buffer[0] = '\0';
if ( loc_Format )
{
::ILocalize::ConstructString( m_loc_Buffer, sizeof( m_loc_Buffer ), loc_Format, 1, CLocalizedStringArg<T>( arg0 ).GetLocArg() );
}
}
template < typename T, typename U >
CConstructLocalizedString( const locchar_t *loc_Format, T arg0, U arg1 )
{
COMPILE_TIME_ASSERT( CLocalizedStringArg<T>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<U>::kIsValid );
m_loc_Buffer[0] = '\0';
if ( loc_Format )
{
::ILocalize::ConstructString( m_loc_Buffer, sizeof( m_loc_Buffer ), loc_Format, 2, CLocalizedStringArg<T>( arg0 ).GetLocArg(), CLocalizedStringArg<U>( arg1 ).GetLocArg() );
}
}
template < typename T, typename U, typename V >
CConstructLocalizedString( const locchar_t *loc_Format, T arg0, U arg1, V arg2 )
{
COMPILE_TIME_ASSERT( CLocalizedStringArg<T>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<U>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<V>::kIsValid );
m_loc_Buffer[0] = '\0';
if ( loc_Format )
{
::ILocalize::ConstructString( m_loc_Buffer,
sizeof( m_loc_Buffer ),
loc_Format,
3,
CLocalizedStringArg<T>( arg0 ).GetLocArg(),
CLocalizedStringArg<U>( arg1 ).GetLocArg(),
CLocalizedStringArg<V>( arg2 ).GetLocArg() );
}
}
template < typename T, typename U, typename V, typename W >
CConstructLocalizedString( const locchar_t *loc_Format, T arg0, U arg1, V arg2, W arg3 )
{
COMPILE_TIME_ASSERT( CLocalizedStringArg<T>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<U>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<V>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<W>::kIsValid );
m_loc_Buffer[0] = '\0';
if ( loc_Format )
{
::ILocalize::ConstructString( m_loc_Buffer,
sizeof( m_loc_Buffer ),
loc_Format,
4,
CLocalizedStringArg<T>( arg0 ).GetLocArg(),
CLocalizedStringArg<U>( arg1 ).GetLocArg(),
CLocalizedStringArg<V>( arg2 ).GetLocArg(),
CLocalizedStringArg<W>( arg3 ).GetLocArg() );
}
}
template < typename T, typename U, typename V, typename W, typename X >
CConstructLocalizedString( const locchar_t *loc_Format, T arg0, U arg1, V arg2, W arg3, X arg4 )
{
COMPILE_TIME_ASSERT( CLocalizedStringArg<T>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<U>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<V>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<W>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<X>::kIsValid );
m_loc_Buffer[0] = '\0';
if ( loc_Format )
{
::ILocalize::ConstructString( m_loc_Buffer,
sizeof( m_loc_Buffer ),
loc_Format,
5,
CLocalizedStringArg<T>( arg0 ).GetLocArg(),
CLocalizedStringArg<U>( arg1 ).GetLocArg(),
CLocalizedStringArg<V>( arg2 ).GetLocArg(),
CLocalizedStringArg<W>( arg3 ).GetLocArg(),
CLocalizedStringArg<X>( arg4 ).GetLocArg() );
}
}
template < typename T, typename U, typename V, typename W, typename X, typename Y >
CConstructLocalizedString( const locchar_t *loc_Format, T arg0, U arg1, V arg2, W arg3, X arg4, Y arg5 )
{
COMPILE_TIME_ASSERT( CLocalizedStringArg<T>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<U>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<V>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<W>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<X>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<Y>::kIsValid );
m_loc_Buffer[0] = '\0';
if ( loc_Format )
{
::ILocalize::ConstructString( m_loc_Buffer,
sizeof( m_loc_Buffer ),
loc_Format,
6,
CLocalizedStringArg<T>( arg0 ).GetLocArg(),
CLocalizedStringArg<U>( arg1 ).GetLocArg(),
CLocalizedStringArg<V>( arg2 ).GetLocArg(),
CLocalizedStringArg<W>( arg3 ).GetLocArg(),
CLocalizedStringArg<X>( arg4 ).GetLocArg(),
CLocalizedStringArg<Y>( arg5 ).GetLocArg() );
}
}
template < typename T, typename U, typename V, typename W, typename X, typename Y, typename Z >
CConstructLocalizedString( const locchar_t *loc_Format, T arg0, U arg1, V arg2, W arg3, X arg4, Y arg5, Z arg6)
{
COMPILE_TIME_ASSERT( CLocalizedStringArg<T>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<U>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<V>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<W>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<X>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<Y>::kIsValid );
COMPILE_TIME_ASSERT( CLocalizedStringArg<Z>::kIsValid );
m_loc_Buffer[0] = '\0';
if ( loc_Format )
{
::ILocalize::ConstructString( m_loc_Buffer,
sizeof( m_loc_Buffer ),
loc_Format,
7,
CLocalizedStringArg<T>( arg0 ).GetLocArg(),
CLocalizedStringArg<U>( arg1 ).GetLocArg(),
CLocalizedStringArg<V>( arg2 ).GetLocArg(),
CLocalizedStringArg<W>( arg3 ).GetLocArg(),
CLocalizedStringArg<X>( arg4 ).GetLocArg(),
CLocalizedStringArg<Y>( arg5 ).GetLocArg(),
CLocalizedStringArg<Z>( arg6 ).GetLocArg() );
}
}
CConstructLocalizedString( const locchar_t *loc_Format, KeyValues *pKeyValues )
{
m_loc_Buffer[0] = '\0';
if ( loc_Format && pKeyValues )
{
::ILocalize::ConstructString( m_loc_Buffer, sizeof( m_loc_Buffer ), loc_Format, pKeyValues );
}
}
operator const locchar_t *() const
{
return m_loc_Buffer;
}
private:
enum { kBufferSize = 512, };
locchar_t m_loc_Buffer[ kBufferSize ];
};
#endif // TIER1_ILOCALIZE_H