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.
262 lines
9.3 KiB
262 lines
9.3 KiB
//====== Copyright © 1996-2005, Valve Corporation, All rights reserved. =======
|
|
//
|
|
// Purpose: provide a layer of abstraction between GC and vgui localization systems
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef LOCALIZATION_PROVIDER_H
|
|
#define LOCALIZATION_PROVIDER_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "language.h"
|
|
|
|
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 loc_strchr wcschr
|
|
#define LOCCHAR(x) L ## x
|
|
|
|
|
|
// interface matches a subset of VGUI functions
|
|
class CLocalizationProvider
|
|
{
|
|
public:
|
|
virtual locchar_t *Find( const char *pchKey ) = 0;
|
|
|
|
virtual void ConstructString( OUT_Z_BYTECAP(unicodeBufferSizeInBytes) locchar_t *unicodeOutput, int unicodeBufferSizeInBytes, const locchar_t *formatString, int numFormatParameters, ... ) = 0;
|
|
virtual void ConstructString( OUT_Z_BYTECAP(unicodeBufferSizeInBytes) locchar_t *unicodeOutput, int unicodeBufferSizeInBytes, const locchar_t *formatString, KeyValues *localizationVariables) = 0;
|
|
|
|
virtual void ConvertLoccharToANSI ( const locchar_t *loc_In, CUtlConstString *out_ansi ) const = 0;
|
|
virtual void ConvertLoccharToUnicode( const locchar_t *loc_In, CUtlConstWideString *out_unicode ) const = 0;
|
|
virtual void ConvertUTF8ToLocchar ( const char *utf8_In, CUtlConstStringBase<locchar_t> *out_loc ) const = 0;
|
|
|
|
virtual int ConvertLoccharToANSI( const locchar_t *loc, OUT_Z_CAP(ansiBufferSize) char *ansi, int ansiBufferSize ) = 0;
|
|
virtual int ConvertLoccharToUnicode( const locchar_t *loc, OUT_Z_BYTECAP(unicodeBufferSizeInBytes) wchar_t *unicode, int unicodeBufferSizeInBytes ) = 0;
|
|
virtual void ConvertUTF8ToLocchar( const char *utf8, OUT_Z_BYTECAP(cubDestSizeInBytes) locchar_t *locchar, int cubDestSizeInBytes ) = 0;
|
|
|
|
virtual ELanguage GetELang() = 0;
|
|
};
|
|
CLocalizationProvider *GLocalizationProvider();
|
|
|
|
#include "vgui/ILocalize.h"
|
|
extern vgui::ILocalize *g_pVGuiLocalize;
|
|
|
|
// Game localization is handled by vgui
|
|
class CVGUILocalizationProvider : public CLocalizationProvider
|
|
{
|
|
public:
|
|
CVGUILocalizationProvider();
|
|
|
|
virtual locchar_t *Find( const char *pchKey );
|
|
|
|
virtual void ConstructString( OUT_Z_BYTECAP(unicodeBufferSizeInBytes) locchar_t *unicodeOutput, int unicodeBufferSizeInBytes, const locchar_t *formatString, int numFormatParameters, ... );
|
|
virtual void ConstructString( OUT_Z_BYTECAP(unicodeBufferSizeInBytes) locchar_t *unicodeOutput, int unicodeBufferSizeInBytes, const locchar_t *formatString, KeyValues *localizationVariables );
|
|
|
|
virtual void ConvertLoccharToANSI ( const locchar_t *loc_In, CUtlConstString *out_ansi ) const;
|
|
virtual void ConvertLoccharToUnicode( const locchar_t *loc_In, CUtlConstWideString *out_unicode ) const;
|
|
virtual void ConvertUTF8ToLocchar ( const char *utf8_In, CUtlConstStringBase<locchar_t> *out_loc ) const;
|
|
|
|
virtual int ConvertLoccharToANSI( const locchar_t *loc, OUT_Z_CAP(ansiBufferSize) char *ansi, int ansiBufferSize );
|
|
virtual int ConvertLoccharToUnicode( const locchar_t *loc, OUT_Z_BYTECAP(unicodeBufferSizeInBytes) wchar_t *unicode, int unicodeBufferSizeInBytes );
|
|
virtual void ConvertUTF8ToLocchar( const char *utf8, OUT_Z_BYTECAP(cubDestSizeInBytes) locchar_t *locchar, int cubDestSizeInBytes );
|
|
|
|
virtual ELanguage GetELang() { return k_Lang_None; }
|
|
};
|
|
|
|
// --------------------------------------------------------------------------
|
|
// 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 { 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_sprintf_safe( m_cBuffer, loc_Format, value ); }
|
|
|
|
const locchar_t *GetLocArg() const { return m_cBuffer; }
|
|
|
|
private:
|
|
enum { kBufferSize = 128, };
|
|
locchar_t m_cBuffer[ kBufferSize ];
|
|
};
|
|
|
|
// --------------------------------------------------------------------------
|
|
|
|
template < >
|
|
class CLocalizedStringArg<uint32> : public CLocalizedStringArgPrintfImpl<uint32>
|
|
{
|
|
public:
|
|
CLocalizedStringArg( uint32 unValue ) : CLocalizedStringArgPrintfImpl<uint32>( unValue, LOCCHAR("%u") ) { }
|
|
};
|
|
|
|
// --------------------------------------------------------------------------
|
|
|
|
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.
|
|
CLocalizedStringArg( float fValue )
|
|
: CLocalizedStringArgPrintfImpl<float>( fValue,
|
|
fabsf( fValue ) < 1.0f ? LOCCHAR("%.1f") : LOCCHAR("%.0f") )
|
|
{
|
|
//
|
|
}
|
|
};
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Purpose:
|
|
// --------------------------------------------------------------------------
|
|
class CConstructLocalizedString
|
|
{
|
|
public:
|
|
template < typename T >
|
|
CConstructLocalizedString( CLocalizationProvider* pLocalizationProvider, const locchar_t *loc_Format, T arg0 )
|
|
{
|
|
Assert( CLocalizedStringArg<T>::kIsValid );
|
|
|
|
m_loc_Buffer[0] = '\0';
|
|
|
|
if ( loc_Format )
|
|
{
|
|
pLocalizationProvider->ConstructString( m_loc_Buffer, sizeof( m_loc_Buffer ), loc_Format, 1, CLocalizedStringArg<T>( arg0 ).GetLocArg() );
|
|
}
|
|
}
|
|
|
|
template < typename T, typename U >
|
|
CConstructLocalizedString( CLocalizationProvider* pLocalizationProvider, const locchar_t *loc_Format, T arg0, U arg1 )
|
|
{
|
|
Assert( CLocalizedStringArg<T>::kIsValid );
|
|
Assert( CLocalizedStringArg<U>::kIsValid );
|
|
|
|
m_loc_Buffer[0] = '\0';
|
|
|
|
if ( loc_Format )
|
|
{
|
|
pLocalizationProvider->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( CLocalizationProvider* pLocalizationProvider, const locchar_t *loc_Format, T arg0, U arg1, V arg2 )
|
|
{
|
|
Assert( CLocalizedStringArg<T>::kIsValid );
|
|
Assert( CLocalizedStringArg<U>::kIsValid );
|
|
Assert( CLocalizedStringArg<V>::kIsValid );
|
|
|
|
m_loc_Buffer[0] = '\0';
|
|
|
|
if ( loc_Format )
|
|
{
|
|
pLocalizationProvider->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( CLocalizationProvider* pLocalizationProvider, const locchar_t *loc_Format, T arg0, U arg1, V arg2, W arg3 )
|
|
{
|
|
Assert( CLocalizedStringArg<T>::kIsValid );
|
|
Assert( CLocalizedStringArg<U>::kIsValid );
|
|
Assert( CLocalizedStringArg<V>::kIsValid );
|
|
Assert( CLocalizedStringArg<W>::kIsValid );
|
|
|
|
m_loc_Buffer[0] = '\0';
|
|
|
|
if ( loc_Format )
|
|
{
|
|
pLocalizationProvider->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() );
|
|
}
|
|
}
|
|
|
|
CConstructLocalizedString( CLocalizationProvider* pLocalizationProvider, const locchar_t *loc_Format, KeyValues *pKeyValues )
|
|
{
|
|
m_loc_Buffer[0] = '\0';
|
|
|
|
if ( loc_Format && pKeyValues )
|
|
{
|
|
pLocalizationProvider->ConstructString( m_loc_Buffer, sizeof( m_loc_Buffer ), loc_Format, pKeyValues );
|
|
}
|
|
}
|
|
|
|
operator const locchar_t *() const
|
|
{
|
|
return Get();
|
|
}
|
|
|
|
const locchar_t *Get() const
|
|
{
|
|
return m_loc_Buffer;
|
|
}
|
|
|
|
private:
|
|
enum { kBufferSize = 512, };
|
|
locchar_t m_loc_Buffer[ kBufferSize ];
|
|
};
|
|
|
|
#endif // LOCALIZATION_PROVIDER_H
|