From 725f68b6808a8a30778f58223fac75386f082785 Mon Sep 17 00:00:00 2001 From: Kirill Volinsky Date: Fri, 18 May 2012 22:10:43 +0000 Subject: plugins folders renaming git-svn-id: http://svn.miranda-ng.org/main/trunk@61 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c --- plugins/Modernb/hdr/modern_skinned_profile.h | 245 +++++++++++++++++++++++++++ 1 file changed, 245 insertions(+) create mode 100644 plugins/Modernb/hdr/modern_skinned_profile.h (limited to 'plugins/Modernb/hdr/modern_skinned_profile.h') diff --git a/plugins/Modernb/hdr/modern_skinned_profile.h b/plugins/Modernb/hdr/modern_skinned_profile.h new file mode 100644 index 0000000000..95ab85c606 --- /dev/null +++ b/plugins/Modernb/hdr/modern_skinned_profile.h @@ -0,0 +1,245 @@ +#ifndef modern_skinned_profile_h__ +#define modern_skinned_profile_h__ + +//#include "modern_commonheaders.h" +//#include "modern_commonprototypes.h" + +#include +#include +//#include + +class MString +{ +private: + TCHAR * _buffer; +public: + MString() : _buffer( NULL ) {}; + MString( const TCHAR * str ) { _buffer = str ? _tcsdup( str ) : NULL; } + MString( const MString& str ) { _buffer = str._buffer ? _tcsdup( str._buffer ) : NULL; } + MString& operator=( const MString& str ) + { + if ( _buffer ) free( _buffer ); + _buffer = str._buffer ? _tcsdup( str._buffer ) : NULL; + } + TCHAR* operator()( const MString& str ) { return _buffer; } + ~MString() + { + if ( _buffer ) + free( _buffer ); + _buffer = NULL; + } + +#ifdef _UNICODE + MString( const char * str) + { + if ( !str ) + _buffer = NULL; + else + { + int cbLen = MultiByteToWideChar( 0, 0, str, -1, NULL, 0 ); + wchar_t* _buffer = ( wchar_t* )malloc( sizeof( wchar_t )*(cbLen+1)); + if ( _buffer == NULL ) return; + MultiByteToWideChar( 0, 0, str, -1, _buffer, cbLen ); + _buffer[ cbLen ] = 0; + } + } +#endif + +}; + +class CAutoCriticalSection +{ +public: + CAutoCriticalSection() //Init critical section here + : _pLinkedCS( NULL ) + { + InitializeCriticalSection( &_CS ); + _ifCSOwner = true; + _ifLocked = false; + } + CAutoCriticalSection( CAutoCriticalSection& Locker, bool doLock = true ) + : _pLinkedCS ( &Locker ) + { + _ifCSOwner = false; + _ifLocked = false; + if ( doLock ) + Lock(); + } + ~CAutoCriticalSection() // Leave if auto locker, and destroy if not + { + if ( _ifLocked ) + Unlock(); + if ( _ifCSOwner ) + DeleteCriticalSection( &_CS ); + } + + void Lock() // Enter Section + { + if ( _ifLocked ) return; + if ( _ifCSOwner ) EnterCriticalSection( &_CS ); + else _pLinkedCS->Lock(); + _ifLocked = true; + return; + } + void Unlock() // Leave Section + { + if ( !_ifLocked ) return; + if ( _ifCSOwner ) LeaveCriticalSection( &_CS ); + else _pLinkedCS->Unlock(); + _ifLocked = false; + } + +private: + CRITICAL_SECTION _CS; + CAutoCriticalSection * _pLinkedCS; + bool _ifCSOwner; + bool _ifLocked; +}; + +class ValueVariant +{ +public: + ValueVariant() : _type( VVT_EMPTY ) {}; + ValueVariant( BYTE bValue ) : _type( VVT_BYTE ), _bValue( bValue ) {}; + ValueVariant( WORD wValue ) : _type( VVT_WORD ), _wValue( wValue ) {}; + ValueVariant( DWORD dwValue ) : _type( VVT_DWORD ), _dwValue( dwValue ) {}; + ValueVariant( const MString& strValue ) : _type( VVT_STRING ), _strValue( strValue ) {}; + ValueVariant( const char * szValue ) : _type( VVT_STRING ), _strValue( szValue ) {}; +#ifdef _UNICODE + ValueVariant( const wchar_t * szValue ) : _type( VVT_STRING ), _strValue( szValue ) {}; +#endif + + BYTE GetByte() + { + switch ( _type ) + { + case VVT_BYTE: + return ( BYTE ) _bValue; + case VVT_WORD: + case VVT_DWORD: + DebugBreak(); + return ( BYTE ) _bValue; + default: + DebugBreak(); + } + return 0; + } + + WORD GetWord() + { + switch ( _type ) + { + case VVT_WORD: + return ( WORD ) _wValue; + + case VVT_BYTE: + case VVT_DWORD: + DebugBreak(); + return ( WORD ) _wValue; + default: + DebugBreak(); + } + return 0; + } + + DWORD GetDword() + { + switch ( _type ) + { + case VVT_DWORD: + return ( DWORD ) _dwValue; + + case VVT_BYTE: + case VVT_WORD: + DebugBreak(); + return ( DWORD ) _dwValue; + default: + DebugBreak(); + } + return 0; + } + MString GetString() + { + switch ( _type ) + { + case VVT_STRING: + return _strValue; + + default: + DebugBreak(); + } + return ""; + } + const MString& GetStringStatic() + { + switch ( _type ) + { + case VVT_STRING: + return _strValue; + + default: + DebugBreak(); + } + return _strValue; + } + bool IsEmpty() { return _type==VVT_EMPTY; } + +private: + enum + { + VVT_EMPTY = 0, + VVT_BYTE, + VVT_WORD, + VVT_DWORD, + VVT_STRING + }; + int _type; + union + { + BYTE _bValue; + WORD _wValue; + DWORD _dwValue; + }; + MString _strValue; + +}; + +// this is single tone class to represent some profile settings to be skinned +class CSkinnedProfile +{ +private: + static CSkinnedProfile _me; + CSkinnedProfile(); + ~CSkinnedProfile(); + +private: + // Skinned profile holded attributes + MString _strSkinFilename; + bool _bLoadedFonts; + bool _bLoadedOthers; + + typedef std::map ValueList_t; + typedef std::map KeyList_t; + + KeyList_t SkinnedProfile; + + ValueVariant* _GetValue( const char * szSection, const char * szKey ); + + CAutoCriticalSection _Lock; // critical section to matable skinned profile access + +public: + static CSkinnedProfile* SkinProfile() { return &_me; } + + HRESULT Init(); + HRESULT Clear(); + + static BYTE SpiGetSkinByte ( HANDLE hContact, const char * szSection, const char * szKey, const BYTE defValue ); + static WORD SpiGetSkinWord ( HANDLE hContact, const char * szSection, const char * szKey, const WORD defValue ); + static DWORD SpiGetSkinDword( HANDLE hContact, const char * szSection, const char * szKey, const DWORD defValue ); + static BOOL SpiCheckSkinned( HANDLE hContact, const char * szSection, const char * szKey ); + +}; + + + +#endif // modern_skinned_profile_h__ \ No newline at end of file -- cgit v1.2.3