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.
 
 
 
 
 
 

406 lines
11 KiB

//=========== Copyright Valve Corporation, All rights reserved. ===============//
//
// Purpose:
//=============================================================================//
#ifndef PANORAMA_ILOCALIZE_H
#define PANORAMA_ILOCALIZE_H
#include "language.h"
#include "tier0/platform.h"
#include "tier1/interface.h"
#include "tier1/utlflags.h"
#include "tier1/utlsymbol.h"
#include "tier1/utlstring.h"
#include "tier1/utlmap.h"
#include "tier1/fileio.h"
#include "tier1/utlpriorityqueue.h"
#include "steam/steamtypes.h"
#if defined( SOURCE2_PANORAMA )
#include "currencyamount.h"
#else
#include "stime.h"
#include "constants.h"
#include "globals.h"
#include "amount.h"
#include "rtime.h"
#endif
#include "reliabletimer.h"
#include "language.h"
namespace panorama
{
//-----------------------------------------------------------------------------
// Purpose: type of variable data we are supporting
//-----------------------------------------------------------------------------
enum EPanelKeyType
{
k_ePanelVartype_None,
k_ePanelVartype_String,
k_ePanelVartype_Time,
k_ePanelVartype_Money,
k_ePanelVartype_Number,
k_ePanelVartype_Generic
};
// help function syntax for the generic key handler
typedef const char *( *PFNLocalizeDialogVariableHandler )( const CUtlString &sStringValue, int nIntValue, const IUIPanel *pPanel, const char *pszKey, void *pUserData );
enum EPanelKeyTimeModifiers
{
k_ePanelKeyTimeModifiers_ShortDate = 1 << 0,
k_ePanelKeyTimeModifiers_LongDate = 1 << 1,
k_ePanelKeyTimeModifiers_ShortTime = 1 << 2,
k_ePanelKeyTimeModifiers_LongTime = 1 << 3,
k_ePanelKeyTimeModifiers_DateTime = 1 << 4,
k_ePanelKeyTimeModifiers_Relative = 1 << 5,
k_ePanelKeyTimeModifiers_Duration = 1 << 6,
};
enum EStringTruncationStyle
{
k_eStringTruncationStyle_None,
k_eStringTruncationStyle_Rear, // prevent any chars being added above max length
k_eStringTruncationStyle_Front, // remove
};
enum EStringTransformStyle
{
k_eStringTransformStyle_None,
k_eStringTransformStyle_Uppercase,
k_eStringTransformStyle_Lowercase,
};
//-----------------------------------------------------------------------------
// Purpose: callback interface to help measuring strings
//-----------------------------------------------------------------------------
class ILocalizationStringSizeResolver
{
public:
virtual ~ILocalizationStringSizeResolver() {}
virtual int ResolveStringLengthInPixels( const char *pchString ) = 0;
};
const uint32 k_nLocalizeMaxChars = (uint32)~0;
class CPanelKeyValue;
class CLocalization;
class CPanel2D;
//-----------------------------------------------------------------------------
// Purpose: interface to final string data to display to users
//-----------------------------------------------------------------------------
class ILocalizationString
{
public:
virtual ~ILocalizationString() {}
// Get the length of the string in characters
virtual int Length() const = 0;
virtual bool IsEmpty() const = 0;
virtual const char *String() const = 0;
virtual const char *StringNoTransform() const = 0;
virtual operator const char *() const = 0;
// add this string on the end
virtual bool AppendText( const char *pchText ) = 0;
// done with this string, delete it
virtual void Release() const = 0;
virtual EStringTransformStyle GetTransformStyle() const = 0;
virtual const IUIPanel *GetOwningPanel() const = 0;
virtual uint32 GetMaxChars() const = 0;
virtual EStringTruncationStyle GetTruncationStyle() const = 0;
#ifdef DBGFLAG_VALIDATE
virtual void Validate( CValidator &validator, const tchar *pchName ) = 0;
#endif
protected:
// internal loc engine helpers, you won't call these
friend class CLocalization;
virtual void Recalculate( const CUtlString *pString ) = 0;
virtual bool BContainsDialogVariable( const CPanelKeyValue &key ) = 0;
};
class CLocStringSafePointer
{
public:
CLocStringSafePointer()
{
m_pString = NULL;
}
CLocStringSafePointer( const ILocalizationString *pLocString )
{
m_pString = pLocString;
}
CLocStringSafePointer &operator =( const ILocalizationString *pString )
{
if ( m_pString == pString )
return *this;
Clear();
m_pString = const_cast<ILocalizationString *>( pString );
return *this;
}
const ILocalizationString *operator ->( ) const
{
return Get();
}
const ILocalizationString *operator *( ) const
{
return Get();
}
operator const ILocalizationString*( ) const
{
return Get();
}
~CLocStringSafePointer()
{
Clear();
}
void Clear()
{
if ( m_pString )
{
m_pString->Release();
m_pString = NULL;
}
}
bool IsValid() { return m_pString != nullptr; }
const ILocalizationString *Get() const
{
return m_pString;
}
private:
const ILocalizationString *m_pString;
};
//-----------------------------------------------------------------------------
// Purpose: interface to localize strings
//-----------------------------------------------------------------------------
class IUILocalization
{
public:
// change the language used by the loc system
virtual bool SetLanguage( const char *pchLanguage ) = 0;
#if defined( SOURCE2_PANORAMA )
// add a loc file to the system, in the form of <prefix>_<language>.txt , i.e dota_french.txt, the files will be loaded from the panorama/localization folder of your mod
virtual bool BLoadLocalizationFile( const char *pchFilePrefix ) = 0;
#else
virtual ELanguage CurrentLanguage() = 0;
#endif
virtual void InstallCustomDialogVariableHandler( const char *pchCustomHandlerName, PFNLocalizeDialogVariableHandler pfnLocalizeFunc, void *pUserData = NULL ) = 0;
virtual void RemoveCustomDialogVariableHandler( const char *pchCustomHandlerName ) = 0;
// find the string corresponding to this localization token, or if we don't find it then just return back the string wrapped in a loc object
virtual const ILocalizationString *PchFindToken( const IUIPanel *pPanel, const char *pchToken, const uint32 ccMax , EStringTruncationStyle eTrunkStyle, EStringTransformStyle eTransformStyle, bool bAllowDialogVariable = false ) = 0;
// give me a localize string wrapper around this string, don't try and apply token localizing on it though, but do optionally allow it to have dialog variables that we parse in it
// be careful allowing dialog variable parsing, you want to sanitize any user input before allowing it
virtual const ILocalizationString *PchSetString( const IUIPanel *pPanel, const char *pchText, const uint32 ccMax, EStringTruncationStyle eTrunkStyle, EStringTransformStyle eTransformStyle, bool bAllowDialogVariable, bool bStringAlreadyFullyParsed ) = 0;
virtual const ILocalizationString *ChangeTransformStyleAndRelease( const ILocalizationString *pLocalizationString, EStringTransformStyle eTranformStyle ) = 0;
// copy an existing loc string without altering the ref count on the current
virtual ILocalizationString *CloneString( const IUIPanel *pPanel, const ILocalizationString *pLocToken ) = 0;
// return the raw, un-parsed, value for this loc token, returns NULL if we didn't have this token in a loc file from disk
virtual const char *PchFindRawString( const char *pchToken ) = 0;
virtual bool SetDialogVariable( const IUIPanel *pPanel, const char *pchKey, const char *pchValue ) = 0;
#if defined( SOURCE2_PANORAMA )
virtual bool SetDialogVariable( const IUIPanel *pPanel, const char *pchKey, time_t timeVal ) = 0;
virtual bool SetDialogVariable( const IUIPanel *pPanel, const char *pchKey, CCurrencyAmount amount ) = 0;
#else
virtual bool SetDialogVariable( const IUIPanel *pPanel, const char *pchKey, CRTime timeVal ) = 0;
virtual bool SetDialogVariable( const IUIPanel *pPanel, const char *pchKey, CAmount amount ) = 0;
#endif
virtual bool SetDialogVariable( const IUIPanel *pPanel, const char *pchKey, int nVal ) = 0;
// copy all the dialog vars to a new panel
virtual void CloneDialogVariables( const IUIPanel *pPanelFrom, IUIPanel *pPanelTo ) = 0;
// force a re-evaluation of a specific dialog variable
virtual void DirtyDialogVariable( const IUIPanel *pPanel, const char *pchKey ) = 0;
// given this loc string find the longest string in any language that we could display here and update to use it
virtual void SetLongestStringForToken( const ILocalizationString *pLocalizationString, ILocalizationStringSizeResolver *pResolver ) = 0;
};
//-----------------------------------------------------------------------------
// Purpose: Wrapper around ILocalizationString that will take care of making
// a copy if it ends up needing to be mutable.
//-----------------------------------------------------------------------------
class CMutableLocalizationString
{
public:
CMutableLocalizationString()
: m_bMutable( false )
, m_pString( NULL )
{
}
CMutableLocalizationString( ILocalizationString *pString )
: m_bMutable( true )
, m_pString( pString )
{
}
CMutableLocalizationString( const ILocalizationString *pString )
: m_bMutable( false )
, m_pString( const_cast< ILocalizationString * >( pString ) )
{
}
CMutableLocalizationString( const CMutableLocalizationString &other )
{
m_bMutable = true;
if ( other.m_pString )
{
m_pString = UILocalize()->CloneString( other.m_pString->GetOwningPanel(), other.m_pString );
}
else
{
m_pString = NULL;
}
}
~CMutableLocalizationString()
{
Clear();
}
const ILocalizationString *Get() const
{
return m_pString;
}
ILocalizationString *GetMutable()
{
if ( m_bMutable || !m_pString )
return m_pString;
ILocalizationString *pOldString = m_pString;
m_pString = UILocalize()->CloneString( pOldString->GetOwningPanel(), pOldString );
m_bMutable = true;
pOldString->Release();
return m_pString;
}
void Clear()
{
if ( m_pString )
{
m_pString->Release();
m_pString = NULL;
}
}
const ILocalizationString *Extract()
{
const ILocalizationString *pString = m_pString;
m_pString = NULL;
return pString;
}
ILocalizationString *ExtractMutable()
{
ILocalizationString *pString = GetMutable();
m_pString = NULL;
return pString;
}
// The -> operator is only overloaded to return a const string. If you need a mutable version, you must call GetMutable directly.
const ILocalizationString *operator ->() const
{
return Get();
}
explicit operator bool() const
{
return Get() != NULL;
}
bool operator ==( const CMutableLocalizationString &other ) const
{
return m_pString == other.m_pString;
}
bool operator !=( const CMutableLocalizationString &other ) const
{
return !( *this == other );
}
bool operator ==( const ILocalizationString *pString ) const
{
return m_pString == pString;
}
bool operator !=( const ILocalizationString *pString ) const
{
return !( *this == pString );
}
CMutableLocalizationString &operator =( const CMutableLocalizationString &other )
{
if ( other.m_pString == m_pString )
return *this;
Clear();
m_bMutable = true;
if ( other.m_pString )
{
m_pString = UILocalize()->CloneString( other.m_pString->GetOwningPanel(), other.m_pString );
}
else
{
m_pString = NULL;
}
return *this;
}
CMutableLocalizationString &operator =( const ILocalizationString *pString )
{
if ( m_pString == pString )
return *this;
Clear();
m_bMutable = false;
m_pString = const_cast< ILocalizationString * >( pString );
return *this;
}
private:
bool m_bMutable;
ILocalizationString *m_pString;;
};
} // namespace panorama
#endif // PANORAMA_ILOCALIZE_H