kalzium/src/kalziumgradienttype.h

   1 /***************************************************************************
   2  *   Copyright (C) 2005, 2006      by Pino Toscano, toscano.pino@tiscali.it      *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  18  ***************************************************************************/
  19
  20 #ifndef KALZIUMGRADIENTTYPE_H
  21 #define KALZIUMGRADIENTTYPE_H
  22
  23 class KalziumGradientType;
  24
  25 #include <QByteArray>
  26 #include <QColor>
  27
  28 /**
  29  * Factory for KalziumGradientType classes.
  30  *
  31  * @author Pino Toscano
  32  */
  33 class KalziumGradientTypeFactory
  34 {
  35         public:
  36                 /**
  37                  * Get the instance of this factory.
  38                  */
  39                 static KalziumGradientTypeFactory* instance();
  40
  41                 /**
  42                  * Returns the KalziumGradientType with the @p id specified.
  43                  * It will gives 0 if none found.
  44                  */
  45                 KalziumGradientType* build( int id ) const;
  46                 /**
  47                  * Returns the KalziumGradientType whose name is the @p id
  48                  * specified.
  49                  * It will gives 0 if none found.
  50                  */
  51                 KalziumGradientType* build( const QByteArray& id ) const;
  52
  53                 /**
  54                  * Returns a list with the names of the gradients we support.
  55                  */
  56                 QStringList gradients() const;
  57
  58         private:
  59                 KalziumGradientTypeFactory();
  60
  61                 QList<KalziumGradientType*> m_gradients;
  62 };
  63
  64 /**
  65  * Base class representing a gradient.
  66  * Inherit it and add its instance to the factory to add it globally.
  67  *
  68  * @author Pino Toscano
  69  */
  70 class KalziumGradientType
  71 {
  72         public:
  73                 /**
  74                  * Get its instance.
  75                  */
  76                 static KalziumGradientType* instance();
  77
  78                 virtual ~KalziumGradientType();
  79
  80                 /**
  81                  * Returns the ID of this gradient.
  82                  * Mainly used when saving/loading.
  83                  */
  84                 virtual QByteArray name() const = 0;
  85                 /**
  86                  * Returns the description of this gradient.
  87                  * Used in all the visible places.
  88                  */
  89                 virtual QString description() const = 0;
  90
  91                 /**
  92                  * Calculate the coefficient of the element with atomic number
  93                  * @p el according to this gradient. The calculated coefficient
  94                  * will be always in the range [0, 1].
  95                  */
  96                 virtual double elementCoeff( int el ) const;
  97                 /**
  98                  * Return the value, related to the current gradient, of the
  99                  * element with atomic number @p el.
 100                  * It will return -1 if the data is not available.
 101                  */
 102                 virtual double value( int el ) const = 0;
 103                 /**
 104                  * Returns the minimum value of the data this gradient
 105                  * represents.
 106                  */
 107                 virtual double minValue() const = 0;
 108                 /**
 109                  * Returns the maximum value of the data this gradient
 110                  * represents.
 111                  */
 112                 virtual double maxValue() const = 0;
 113                 /**
 114                  * Returns whether to use a logarithmic gradient
 115                  * instead of a linear one.
 116                  */
 117                 virtual bool logarithmicGradient() const = 0;
 118                 /**
 119                  * Returns the first color of the gradient.
 120                  */
 121                 virtual QColor firstColor() const;
 122                 /**
 123                  * Returns the second color of the gradient.
 124                  */
 125                 virtual QColor secondColor() const;
 126                 /**
 127                  * Returns the color used to represent an element whose data is
 128                  * not available.
 129                  */
 130                 virtual QColor notAvailableColor() const;
 131
 132                 /**
 133                  * Calculates the color of an element which has a @p coeff which
 134                  * is a percentage of the maximum value.
 135                  * @param coeff is the coefficient in the range [0, 1], usually
 136                  * calculated with elementCoeff()
 137                  */
 138                 QColor calculateColor( const double coeff ) const;
 139
 140         protected:
 141                 KalziumGradientType();
 142 };
 143
 144 /**
 145  * The gradient by covalent radius.
 146  *
 147  * @author Pino Toscano
 148  */
 149 class KalziumCovalentRadiusGradientType : public KalziumGradientType
 150 {
 151         public:
 152                 static KalziumCovalentRadiusGradientType* instance();
 153
 154                 QByteArray name() const;
 155                 QString description() const;
 156
 157                 double value( int el ) const;
 158
 159                 double minValue() const;
 160                 double maxValue() const;
 161
 162                 bool logarithmicGradient() const;
 163
 164         private:
 165                 KalziumCovalentRadiusGradientType();
 166 };
 167
 168 /**
 169  * The gradient by van Der Waals radius.
 170  *
 171  * @author Pino Toscano
 172  */
 173 class KalziumVanDerWaalsRadiusGradientType : public KalziumGradientType
 174 {
 175         public:
 176                 static KalziumVanDerWaalsRadiusGradientType* instance();
 177
 178                 QByteArray name() const;
 179                 QString description() const;
 180
 181                 double value( int el ) const;
 182
 183                 double minValue() const;
 184                 double maxValue() const;
 185
 186                 bool logarithmicGradient() const;
 187
 188         private:
 189                 KalziumVanDerWaalsRadiusGradientType();
 190 };
 191
 192 /**
 193  * The gradient by atomic mass.
 194  *
 195  * @author Pino Toscano
 196  */
 197 class KalziumMassGradientType : public KalziumGradientType
 198 {
 199         public:
 200                 static KalziumMassGradientType* instance();
 201
 202                 QByteArray name() const;
 203                 QString description() const;
 204
 205                 double value( int el ) const;
 206
 207                 double minValue() const;
 208                 double maxValue() const;
 209
 210                 bool logarithmicGradient() const;
 211
 212         private:
 213                 KalziumMassGradientType();
 214 };
 215
 216 /**
 217  * The gradient by boiling point.
 218  *
 219  * @author Pino Toscano
 220  */
 221 class KalziumBoilingPointGradientType : public KalziumGradientType
 222 {
 223         public:
 224                 static KalziumBoilingPointGradientType* instance();
 225
 226                 QByteArray name() const;
 227                 QString description() const;
 228
 229                 double value( int el ) const;
 230
 231                 double minValue() const;
 232                 double maxValue() const;
 233
 234                 bool logarithmicGradient() const;
 235
 236         private:
 237                 KalziumBoilingPointGradientType();
 238 };
 239
 240 /**
 241  * The gradient by melting point.
 242  *
 243  * @author Pino Toscano
 244  */
 245 class KalziumMeltingPointGradientType : public KalziumGradientType
 246 {
 247         public:
 248                 static KalziumMeltingPointGradientType* instance();
 249
 250                 QByteArray name() const;
 251                 QString description() const;
 252
 253                 double value( int el ) const;
 254
 255                 double minValue() const;
 256                 double maxValue() const;
 257
 258                 bool logarithmicGradient() const;
 259
 260         private:
 261                 KalziumMeltingPointGradientType();
 262 };
 263
 264 /**
 265  * The gradient by electronegativity.
 266  *
 267  * @author Pino Toscano
 268  */
 269 class KalziumElectronegativityGradientType : public KalziumGradientType
 270 {
 271         public:
 272                 static KalziumElectronegativityGradientType* instance();
 273
 274                 QByteArray name() const;
 275                 QString description() const;
 276
 277                 double value( int el ) const;
 278
 279                 double minValue() const;
 280                 double maxValue() const;
 281
 282                 bool logarithmicGradient() const;
 283
 284         private:
 285                 KalziumElectronegativityGradientType();
 286 };
 287
 288 /**
 289  * The gradient by discoverydate.
 290  *
 291  * @author Carsten Niehaus
 292  */
 293 class KalziumDiscoverydateGradientType : public KalziumGradientType
 294 {
 295         public:
 296                 static KalziumDiscoverydateGradientType* instance();
 297
 298                 QByteArray name() const;
 299                 QString description() const;
 300
 301                 double value( int el ) const;
 302
 303                 double minValue() const;
 304                 double maxValue() const;
 305
 306                 bool logarithmicGradient() const;
 307
 308         private:
 309                 KalziumDiscoverydateGradientType();
 310 };
 311
 312 /**
 313  * The gradient by electronaffinity.
 314  *
 315  * @author Carsten Niehaus
 316  */
 317 class KalziumElectronaffinityGradientType : public KalziumGradientType
 318 {
 319         public:
 320                 static KalziumElectronaffinityGradientType* instance();
 321
 322                 QByteArray name() const;
 323                 QString description() const;
 324
 325                 double value( int el ) const;
 326
 327                 double minValue() const;
 328                 double maxValue() const;
 329
 330                 bool logarithmicGradient() const;
 331
 332         private:
 333                 KalziumElectronaffinityGradientType();
 334 };
 335
 336 /**
 337  * The gradient by the first ionization energy.
 338  *
 339  * @author Carsten Niehaus
 340  */
 341 class KalziumIonizationGradientType : public KalziumGradientType
 342 {
 343         public:
 344                 static KalziumIonizationGradientType* instance();
 345
 346                 QByteArray name() const;
 347                 QString description() const;
 348
 349                 double value( int el ) const;
 350
 351                 double minValue() const;
 352                 double maxValue() const;
 353
 354                 bool logarithmicGradient() const;
 355
 356         private:
 357                 KalziumIonizationGradientType();
 358 };
 359
 360 #endif // KALZIUMGRADIENTTYPE_H