//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : EGkColor.h           Data : 24.02.14          Versione : 1.5c9
// Contenuto : Dichiarazione della classe Color.
//
//
//
// Modifiche : 24.02.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

#pragma once

#include <string>

//----------------------- Macro per import/export ----------------------------
#undef EGK_EXPORT
#if defined( I_AM_EGK)            // da definirsi solo nella DLL
   #define EGK_EXPORT __declspec( dllexport)
#else
   #define EGK_EXPORT __declspec( dllimport)
#endif

//-----------------------------------------------------------------------------
const int MAX_RGB = 255 ;
const int MAX_ALPHA = 100 ;
const int ALPHA_LIM = 90 ;                       // valore di opacità equivalente al 100%
const float INV_MAX_RGB = 1 / float( MAX_RGB) ;
const float INV_MAX_ALPHA = 1 / float( MAX_ALPHA) ;

//-----------------------------------------------------------------------------
class Color
{
   public :
      Color( void)
             { m_Col[RED] = 0 ; m_Col[GREEN] = 0 ; m_Col[BLUE] = 0 ; m_Col[ALPHA] = MAX_ALPHA ; }
      Color( int nRed, int nGreen, int nBlue, int nAlpha = MAX_ALPHA)
            { Set( nRed, nGreen, nBlue, nAlpha) ; }
      Color( const int vCol[4])
            { Set( vCol[0], vCol[1], vCol[2], vCol[3]) ; }
      Color( double dRed, double dGreen, double dBlue, double dAlpha = 1)
            { Set( dRed, dGreen, dBlue, dAlpha) ; }
      void Set( void)
             { m_Col[RED] = 0 ; m_Col[GREEN] = 0 ; m_Col[BLUE] = 0 ; m_Col[ALPHA] = MAX_ALPHA ; }
      void Set( int nRed, int nGreen, int nBlue, int nAlpha = MAX_ALPHA)
            { m_Col[RED] = (( nRed < 0) ? 0 : (( nRed > MAX_RGB) ? MAX_RGB : nRed)) ;
              m_Col[GREEN] = (( nGreen < 0) ? 0 : (( nGreen > MAX_RGB) ? MAX_RGB : nGreen)) ;
              m_Col[BLUE] = (( nBlue < 0) ? 0 : (( nBlue > MAX_RGB) ? MAX_RGB : nBlue)) ;
              m_Col[ALPHA] = (( nAlpha < 0) ? 0 : (( nAlpha > MAX_ALPHA) ? MAX_ALPHA : nAlpha)) ; }
      void Set( const int vCol[4])
            { Set( vCol[0], vCol[1], vCol[2], vCol[3]) ; }
      void Set( double dRed, double dGreen, double dBlue, double dAlpha = 1)
            { m_Col[RED] = (( dRed < 0) ? 0 : (( dRed > 1) ? MAX_RGB : int( lround( dRed * MAX_RGB)))) ;
              m_Col[GREEN] = (( dGreen < 0) ? 0 : (( dGreen > 1) ? MAX_RGB : int( lround( dGreen * MAX_RGB)))) ;
              m_Col[BLUE] = (( dBlue < 0) ? 0 : (( dBlue > 1) ? MAX_RGB : int( lround( dBlue * MAX_RGB)))) ;
              m_Col[ALPHA] = (( dAlpha < 0) ? 0 : (( dAlpha > 1) ? MAX_ALPHA : int( lround( dAlpha * MAX_ALPHA)))) ; }
      void SetAlpha( int nAlpha)
            { m_Col[ALPHA] = (( nAlpha < 0) ? 0 : (( nAlpha > MAX_ALPHA) ? MAX_ALPHA : nAlpha)) ; }
      void SetAlpha( double dAlpha)
            { m_Col[ALPHA] = (( dAlpha < 0) ? 0 : (( dAlpha > 1) ? MAX_ALPHA : int( lround( dAlpha * MAX_ALPHA)))) ; }
      void Intensify( double dCoeff)
            { Set( int( m_Col[RED] * dCoeff), int( m_Col[GREEN] * dCoeff), int( m_Col[BLUE] * dCoeff), m_Col[ALPHA]) ;
              if ( dCoeff > 1  &&  m_Col[RED] < 64  &&  m_Col[GREEN] < 64  &&  m_Col[BLUE] < 64)
                 Set( 64, 64, 64, m_Col[ALPHA]) ; }
      int GetIntRed( void) const
            { return m_Col[RED] ; }
      int GetIntGreen( void) const
            { return m_Col[GREEN] ; }
      int GetIntBlue( void) const
            { return m_Col[BLUE] ; }
      int GetIntAlpha( void) const
            { return m_Col[ALPHA] ; }
      void GetInt( int vCol[4]) const
            { vCol[0] = m_Col[RED] ; vCol[1] = m_Col[GREEN] ; vCol[2] = m_Col[BLUE] ; vCol[3] = m_Col[ALPHA] ; }
      int GetIntIntensity( void) const
            { return ( m_Col[RED] + m_Col[GREEN] + m_Col[BLUE]) / 3 ; }
      float GetRed( void) const
            { return ( m_Col[RED] * INV_MAX_RGB) ; }
      float GetGreen( void) const
            { return (  m_Col[GREEN] * INV_MAX_RGB) ; }
      float GetBlue( void) const
            { return ( m_Col[BLUE] * INV_MAX_RGB) ; }
      float GetAlpha( void) const
            { return ( m_Col[ALPHA] * INV_MAX_ALPHA) ; }
      void GetFloat( float vCol[4]) const
            { vCol[0] = m_Col[RED] * INV_MAX_RGB ; vCol[1] = m_Col[GREEN] * INV_MAX_RGB ;
              vCol[2] = m_Col[BLUE] * INV_MAX_RGB ; vCol[3] = m_Col[ALPHA] * INV_MAX_ALPHA ; }
      float GetIntensity( void) const
            { return ( m_Col[RED] + m_Col[GREEN] + m_Col[BLUE]) / 3 * INV_MAX_RGB ; }
      bool operator == ( const Color& other) const
            { return ( m_Col[RED] == other.m_Col[RED] &&
                       m_Col[GREEN] == other.m_Col[GREEN] &&
                       m_Col[BLUE] == other.m_Col[BLUE] &&
                       m_Col[ALPHA] == other.m_Col[ALPHA]) ; }

   private :
      enum { RED = 0, GREEN = 1, BLUE = 2, ALPHA = 3, DIM = 4} ;

   private :
      unsigned char m_Col[DIM] ;
} ;

//----------------------------------------------------------------------------
// Colori predefiniti
//----------------------------------------------------------------------------
const Color WHITE( 255, 255, 255) ;
const Color LGRAY( 192, 192, 192) ;
const Color GRAY( 128, 128, 128) ;
const Color BLACK( 0, 0, 0) ;
const Color RED( 255, 0, 0) ;
const Color MAROON( 128, 0, 0) ;
const Color YELLOW( 255, 255, 0) ;
const Color OLIVE( 128, 128, 0) ;
const Color LIME( 0, 255, 0) ;
const Color GREEN( 0, 128, 0) ;
const Color AQUA( 0, 255, 255) ;
const Color TEAL( 0, 128, 128) ;
const Color BLUE( 0, 0, 255) ;
const Color NAVY( 0, 0, 128) ;
const Color FUCHSIA( 255, 0, 255) ;
const Color PURPLE( 128, 0, 128) ;
const Color ORANGE( 255, 165, 0) ;
const Color BROWN( 150, 75, 0) ;
const Color INVISIBLE( 0, 0, 0, 0) ;

//----------------------------------------------------------------------------
EGK_EXPORT bool GetStdColor( const std::string& sName, Color& cCol) ;
EGK_EXPORT bool GetNameOfStdColor( Color cCol, std::string& sName) ;
EGK_EXPORT Color GetOppositeColor( Color cCol) ;
EGK_EXPORT Color GetSurfBackColor( Color cCol) ;

//----------------------------------------------------------------------------
struct HSV {
   double dHue ;
   double dSat ;
   double dVal ;
   HSV( void) : dHue( 0), dSat( 0), dVal( 0) {}
   HSV( double dH, double dS, double dV) : dHue( dH), dSat( dS), dVal( dV) {}
} ;

//----------------------------------------------------------------------------
EGK_EXPORT HSV GetHSVFromColor( const Color& cCol) ;
EGK_EXPORT Color GetColorFromHSV( const HSV& hsv) ;